obsidian-semantic

main.ts (6605B)

---

 import { SemanticsSettings } from 'SemanticsSettings';
 import { App, Editor, MarkdownView, Modal, Notice, Plugin, SuggestModal, TFile, TFolder, Vault, requestUrl, RequestUrlParam } from 'obsidian';
 import * as path from 'path';
 import { SemanticApi } from 'SemanticApi';
 import { sanitize } from 'sanitize-filename-ts';
 
 interface SemanticSettings {
 	papersPath: string;
 	apiKey?: string;
 }
 
 const DEFAULT_SETTINGS: SemanticSettings = {
 	papersPath: 'papers',
 	apiKey: undefined
 }
 
 class SemInfos {
 	bibtex: string;
 	id?: string;
 
 	constructor(bibtex: string, id?: string) {
 		this.bibtex = bibtex;
 		this.id = id;
 	}
 
 	static async fromFile(app: App, file: TFile): Promise<SemInfos> {
 		var id: string | undefined = undefined;
 		await app.fileManager.processFrontMatter(file, (frontmatter) => {
 			id = frontmatter["semid"];
 		});
 		var content = await app.vault.cachedRead(file);
 		var bibtex = "";
 		var inblock = false;
 
 		// Extracts the first bibtex block of the file
 		for (const line of content.split(/\r?\n/)) {
 			if (line.trim() == '```bibtex' && !inblock) {
 				inblock = true;
 			} else if (line.trim() == '```' && inblock) {
 				// Finished the bibtex block
 				break;
 			} else if (inblock) {
 				bibtex += line + "\n";
 			}
 		}
 
 		return new SemInfos(bibtex, id);
 	}
 }
 
 class Author {
 	authorId: string;
 	name: string;
 }
 
 class Paper {
 	paperId: string;
 	title: string;
 	authors: Author[];
 	year: string;
 	externalIds?: { DBLP?: string };
 	citationStyles?: { bibtex: string };
 	citations?: Paper[];
 	references?: Paper[];
 
 	static fields(): string {
 		return "title,authors,year,paperId";
 	}
 
 	static fieldsLong(): string {
 		return Paper.fields() + ",externalIds,citationStyles,citations,references"
 	}
 
 	static async get(api: SemanticApi, id: string, long?: boolean, key?: string): Promise<Paper> {
 		return api.request(`paper/${id.trim()}`, {
 			"fields": long ? Paper.fields() : Paper.fieldsLong()
 		}).json;
 	}
 
 	static async getBulk(api: SemanticApi, ids: string[], long?: boolean, key?: string): Promise<Paper[]> {
 		return api.request("paper/batch", {
 			"fields": long ? Paper.fields() : Paper.fieldsLong(),
 		}, {
 			method: "POST",
 			contentType: "application/json",
 			body: JSON.stringify({ids: ids}),
 		}).json;
 	}
 }
 
 export default class SemanticIntegration extends Plugin {
 	settings: SemanticSettings;
 	apiAccess: SemanticApi;
 
 	openModal() {
 		new SemanticModal(this.app, this.settings, this.apiAccess).open();
 	}
 
 	getPapersFolder(): TFolder {
 		var mfolder = this.app.vault.getAbstractFileByPath(this.settings.papersPath);
 		if (mfolder instanceof TFolder) {
 			return mfolder;
 		} else {
 			throw new Error("Papers folder is not a folder");
 		}
 	}
 
 	async onload() {
 		await this.loadSettings();
 
 		this.addRibbonIcon('book-plus', 'Add a new reference', (evt: MouseEvent) => {
 			this.openModal();
 		});
 
 		// this.addCommand({
 		// 	id: 'get-semantic-infos',
 		// 	name: 'Get semantic informations',
 		// 	callback: () => {
 		// 		this.getNoteInfos();
 		// 	}
 		// })
 
 		this.addCommand({
 			id: 'open-semantic-modal',
 			name: 'Open Semantic Scholar search',
 			callback: () => {
 				this.openModal();
 			}
 		});
 
 		this.addCommand({
 			id: "extract-bibtex",
 			name: 'Extract bibliography to bibtex',
 			callback: async () => {
 				var allbibtex: string = "";
 
 				var folder = this.getPapersFolder();
 				for (const mfile of folder.children) {
 					if (mfile instanceof TFile) {
 						var infos = await SemInfos.fromFile(this.app, mfile);
 						allbibtex += infos.bibtex;
 					}
 				}
 				var oldfile = this.app.vault.getFileByPath("biblio.bib")
 				if (oldfile != null) {
 					await this.app.vault.modify(oldfile, allbibtex);
 				} else {
 					await this.app.vault.create("biblio.bib", allbibtex);
 				}
 			}
 		});
 
 		this.addCommand({
 			id: 'search-papers',
 			name: 'Search list of papers',
 			callback: async () => {
 				var folder = this.getPapersFolder();
 
 				var ids = [];
 				for (const file of folder.children) {
 					if (file instanceof TFile) {
 						var infos = await SemInfos.fromFile(this.app, file);
 						if (infos.id != undefined) {
 							ids.push(infos.id);
 						}
 					}
 				}
 
 				// TODO: fuzzy modal
 				console.log(await Paper.getBulk(this.apiAccess, ids));
 			}
 		})
 
 		this.addSettingTab(new SemanticsSettings(this.app, this));
 	}
 
 	onunload() {
 	}
 
 	async loadSettings() {
 		this.settings = Object.assign({}, DEFAULT_SETTINGS, await this.loadData());
 		this.apiAccess = new SemanticApi(this.settings.apiKey)
 	}
 
 	async saveSettings() {
 		await this.saveData(this.settings);
 	}
 
 	async getNoteInfos() {
 		var file = this.app.workspace.getActiveFile();
 		if (file == null) {
 			return;
 		}
 
 		var infos = await SemInfos.fromFile(this.app, file);
 		if (infos.id != undefined) {
 			console.log(await Paper.get(this.apiAccess, infos.id, true));
 		}
 	}
 }
 
 class SemanticModal extends SuggestModal<Paper> {
 	options: SemanticSettings;
 	apiAccess: SemanticApi;
 
 	constructor(app: App, options: SemanticSettings, api: SemanticApi) {
 		super(app);
 		this.options = options;
 		this.apiAccess = api;
 	}
 
 	async getSuggestions(query: string): Promise<Paper[]> {
 		if (query == "") {
 			return [];
 		}
 
 		var result: Paper[] = (await this.apiAccess.debouncedRequest("paper/search", {
 			"query": query,
 			"fields": Paper.fields(),
 			"limit": String(10)
 		})).json.data;
 
 		return result;
 	}
 
 	renderSuggestion(value: Paper, el: HTMLElement) {
 		el.createEl("div", { text: value.title });
 
 		var authors = "";
 		if (value.authors.length <= 2) {
 			authors = value.authors.map(auth => auth.name).join("");
 		} else {
 			authors = `${value.authors[0].name} et al.`
 		}
 
 		el.createEl("small", { text: `${value.year} - ${authors}` });
 	}
 
 	async onChooseSuggestion(item: Paper, evt: MouseEvent | KeyboardEvent) {
 		var final = await Paper.get(this.apiAccess, item.paperId);
 
 		var fname = path.join(this.options.papersPath, sanitize(final.title)) + ".md";
 
 		if (final.citationStyles == undefined || final.externalIds == undefined) {
 			throw new Error("Missing fields in paper");
 		}
 
 		// Generate the body of the note
 		var body = "";
 		var unparsedbib = final.citationStyles.bibtex;
 		if (final.externalIds.DBLP != undefined) {
 			var result = await requestUrl(`https://dblp.org/rec/${final.externalIds.DBLP}.bib?param=0`).text;
 			unparsedbib = result.trim();
 		}
 
 		var body = `\`\`\`bibtex
 ${unparsedbib}
 \`\`\`
 `
 		var file = await this.app.vault.create(fname, body);
 		this.app.fileManager.processFrontMatter(file, (frontmatter) => {
 			frontmatter["semid"] = final.paperId;
 		})
 		await this.app.workspace.openLinkText(fname, fname);
 	}
 }