diff --git a/README.md b/README.md index f40ddfc..d2c52aa 100644 --- a/README.md +++ b/README.md @@ -1,137 +1,9 @@ -# Obsidian Sample Plugin (Deno) +# Obsidian Limitless Plugin (Unofficial) -A nearly-exact port of the original Obsidian sample plugin, but using Deno -instead of Node.js and npm. The plugin files have been copied exactly, but the -helper functions have been moved into Obsideno, a Deno-based CLI helper for -writing Obsidian plugins. Its functions include: +> You need to own a Limitless Pendant to use this plugin! +> This is a requirement for access to the Limitless API, which is not open to normal Limitless users at this time. -- Building the plugin code using Vite instead of ESBuild directly -- Bumping versions with a command, using patch/minor/major Semver language -- Installing and uninstalling your plugin from your test vault, using symlinks - for quick development +A plugin for syncing your Limitless Pendant life logs to a directory in your vault. -Both this repo and Obsideno are pretty barebones, but that's what felt right for -the moment. I just wanted to be able to make new plugins quickly. - -**The original README.md contents:** - -This is a sample plugin for Obsidian (https://obsidian.md). - -This project uses TypeScript to provide type checking and documentation. The -repo depends on the latest plugin API (obsidian.d.ts) in TypeScript Definition -format, which contains TSDoc comments describing what it does. - -This sample plugin demonstrates some of the basic functionality the plugin API -can do. - -- Adds a ribbon icon, which shows a Notice when clicked. -- Adds a command "Open Sample Modal" which opens a Modal. -- Adds a plugin setting tab to the settings page. -- Registers a global click event and output 'click' to the console. -- Registers a global interval which logs 'setInterval' to the console. - -## First time developing plugins? - -Quick starting guide for new plugin devs: - -- Check if - [someone already developed a plugin for what you want](https://obsidian.md/plugins)! - There might be an existing plugin similar enough that you can partner up with. -- Make a copy of this repo as a template with the "Use this template" button - (login to GitHub if you don't see it). -- Clone your repo to a local development folder. For convenience, you can place - this folder in your `.obsidian/plugins/your-plugin-name` folder. -- Install NodeJS, then run `npm i` in the command line under your repo folder. -- Run `npm run dev` to compile your plugin from `main.ts` to `main.js`. -- Make changes to `main.ts` (or create new `.ts` files). Those changes should be - automatically compiled into `main.js`. -- Reload Obsidian to load the new version of your plugin. -- Enable plugin in settings window. -- For updates to the Obsidian API run `npm update` in the command line under - your repo folder. - -## Releasing new releases - -- Update your `manifest.json` with your new version number, such as `1.0.1`, and - the minimum Obsidian version required for your latest release. -- Update your `versions.json` file with - `"new-plugin-version": "minimum-obsidian-version"` so older versions of - Obsidian can download an older version of your plugin that's compatible. -- Create new GitHub release using your new version number as the "Tag version". - Use the exact version number, don't include a prefix `v`. See here for an - example: https://github.com/obsidianmd/obsidian-sample-plugin/releases -- Upload the files `manifest.json`, `main.js`, `styles.css` as binary - attachments. Note: The manifest.json file must be in two places, first the - root path of your repository and also in the release. -- Publish the release. - -> You can simplify the version bump process by running `npm version patch`, -> `npm version minor` or `npm version major` after updating `minAppVersion` -> manually in `manifest.json`. The command will bump version in `manifest.json` -> and `package.json`, and add the entry for the new version to `versions.json` - -## Adding your plugin to the community plugin list - -- Check the - [plugin guidelines](https://docs.obsidian.md/Plugins/Releasing/Plugin+guidelines). -- Publish an initial version. -- Make sure you have a `README.md` file in the root of your repo. -- Make a pull request at https://github.com/obsidianmd/obsidian-releases to add - your plugin. - -## How to use - -- Clone this repo. -- Make sure your NodeJS is at least v16 (`node --version`). -- `npm i` or `yarn` to install dependencies. -- `npm run dev` to start compilation in watch mode. - -## Manually installing the plugin - -- Copy over `main.js`, `styles.css`, `manifest.json` to your vault - `VaultFolder/.obsidian/plugins/your-plugin-id/`. - -## Improve code quality with eslint (optional) - -- [ESLint](https://eslint.org/) is a tool that analyzes your code to quickly - find problems. You can run ESLint against your plugin to find common bugs and - ways to improve your code. -- To use eslint with this project, make sure to install eslint from terminal: - - `npm install -g eslint` -- To use eslint to analyze this project use this command: - - `eslint main.ts` - - eslint will then create a report with suggestions for code improvement by - file and line number. -- If your source code is in a folder, such as `src`, you can use eslint with - this command to analyze all files in that folder: - - `eslint .\src\` - -## Funding URL - -You can include funding URLs where people who use your plugin can financially -support it. - -The simple way is to set the `fundingUrl` field to your link in your -`manifest.json` file: - -```json -{ - "fundingUrl": "https://buymeacoffee.com" -} -``` - -If you have multiple URLs, you can also do: - -```json -{ - "fundingUrl": { - "Buy Me a Coffee": "https://buymeacoffee.com", - "GitHub Sponsor": "https://github.com/sponsors", - "Patreon": "https://www.patreon.com/" - } -} -``` - -## API Documentation - -See https://github.com/obsidianmd/obsidian-api +Since the Limitless API is a work in progress, expect this plugin to change over time. +For now, the intended functionality is to download your lifelogs and place them in a directory. diff --git a/actors/lifelogs/query.ts b/actors/lifelogs/query.ts new file mode 100644 index 0000000..4bdeeb4 --- /dev/null +++ b/actors/lifelogs/query.ts @@ -0,0 +1,110 @@ +import { fromPromise } from "xstate"; +import { request } from "obsidian"; + +interface QueryInput { + apiKey: string; + start: Date; + end: Date; + cursor: string | null; +} + +export interface ContentNode { + /** Type of content node (e.g., heading1, heading2, heading3, blockquote). More types might be added. */ + type: string; + + /** Content of the node. */ + content: string; + + /** ISO format in given timezone. */ + startTime: string; + + /** ISO format in given timezone. */ + endTime: string; + + /** Milliseconds after the start of this entry. */ + startOffsetMs: number; + + /** Milliseconds after the start of this entry. */ + endOffsetMs: number; + + /** Child content nodes. */ + children?: ContentNode[]; + + /** Speaker identifier, present for certain node types (e.g., blockquote). */ + speakerName: string | null; + + /** Speaker identifier, when applicable. Set to "user" when the speaker has been identified as the user. */ + speakerIdentifier: string | null; +} + +export interface Lifelog { + /** Unique identifier for this entry. */ + id: string; + + /** Title of the entry. Equal to the first heading1 node. */ + title: string; + + /** Raw markdown content of the entry. */ + markdown: string; + + /** List of ContentNodes. */ + contents: ContentNode[]; + + /** ISO format in given timezone. */ + startTime: string; + + /** ISO format in given timezone. */ + endTime: string; +} + +export interface LifelogsResponse { + data: { + lifelogs: Lifelog[]; + }; + meta: { + lifelogs: { + /** Cursor for pagination to retireve the next set of lifelogs. */ + nextCursor?: string | null; + + /** Number of lifelogs in the current response. */ + count: number; + }; + }; +} + +export const queryLifelogs = fromPromise( + async ({ input }: { input: QueryInput }) => { + // return await input.client.get("lifelogs", { + // searchParams: { + // start: format(input.start), + // end: format(input.end), + // ...(input.cursor ? { cursor: input.cursor } : {}), + // }, + // }).json(); + const url = new URL("https://api.limitless.ai/v1/lifelogs"); + + url.searchParams.set("start", input.start.toISOString()); + url.searchParams.set("end", input.end.toISOString()); + url.searchParams.set("includeMarkdown", "false"); + + if (input.cursor) { + url.searchParams.set("cursor", input.cursor); + } + + try { + const res = await request({ + url: url.toString(), + headers: { + "X-API-Key": input.apiKey, + }, + }); + + console.log(res); + + return JSON.parse(res) as LifelogsResponse; + } catch (err) { + console.error(err); + throw err; + } + }, +); diff --git a/actors/lifelogs/write.ts b/actors/lifelogs/write.ts new file mode 100644 index 0000000..98ca8d6 --- /dev/null +++ b/actors/lifelogs/write.ts @@ -0,0 +1,59 @@ +import { fromPromise } from "xstate"; +import { TFile, Vault } from "obsidian"; +import { format, parse } from "@formkit/tempo"; +import { ContentNode, Lifelog } from "./query.ts"; + +interface WriteInput { + vault: Vault; + lifelog: Lifelog; + rootDir: string; +} + +// We could just use the markdown output, but the heading levels +// are one unit too high, and we don't need the timestamp links +function formatContentBlock(content: ContentNode): string { + let markdown = ""; + + if (content.type.startsWith("heading")) { + const [, level] = content.type.split("heading"); + const levelNum = Number(level); + + markdown += `${"#".repeat(levelNum + 1)} ${content.content}`; + } else if (content.type === "blockquote") { + markdown += `> ${content.speakerName}: ${content.content}`; + } + + for (const node of content?.children ?? []) { + markdown += `\n\n${formatContentBlock(node)}`; + } + + return markdown; +} + +export const writeLifelog = fromPromise( + async ({ input }: { input: WriteInput }) => { + const { vault, lifelog, rootDir } = input; + const start = parse(lifelog.startTime); + const markdown = lifelog.contents.reduce((str, content) => { + return str + `\n\n${formatContentBlock(content)}`; + }, ""); + + const folder = `${rootDir}/${format(start, "YYYY-MM")}`; + const file = `${format(start, "DD")}.md`; + + const dir = vault.getAbstractFileByPath(folder); + if (dir === null) { + await vault.createFolder(folder); + } + + const abstract = vault.getAbstractFileByPath(`${folder}/${file}`); + if (abstract instanceof TFile) { + await vault.append(abstract, markdown); + } else { + const page = `# ${format(start, "YYYY-MM-DD")}\n\n${markdown}`; + await vault.create(`${folder}/${file}`, page); + } + + return parse(lifelog.endTime); + }, +); diff --git a/actors/plugin.ts b/actors/plugin.ts new file mode 100644 index 0000000..763f032 --- /dev/null +++ b/actors/plugin.ts @@ -0,0 +1,162 @@ +import { assign, setup } from "xstate"; +import { Lifelog, LifelogsResponse, queryLifelogs } from "./lifelogs/query.ts"; +import { writeLifelog } from "./lifelogs/write.ts"; +import { addDay, isAfter, parse } from "@formkit/tempo"; +import { LimitlessPluginSettings } from "../settings.ts"; +import { Vault } from "obsidian"; + +export interface Context { + vault: Vault; + apiKey: string; + latestLog?: Date; + lifelogsDir: string; + cursor: string | null; + lifelogQueue: Lifelog[]; +} + +export type Input = LimitlessPluginSettings & { + vault: Vault; +}; + +export const pluginActor = setup({ + types: { + context: {} as Context, + input: {} as Input, + }, + actors: { + queryLifelogs, + writeLifelog, + }, + guards: { + lifelogQueueNotEmpty: ({ context }) => context.lifelogQueue.length > 0, + apiReturnedLifelogs: (_, params: LifelogsResponse) => + params.data.lifelogs.length > 0, + hasCursor: ({ context }) => Boolean(context.cursor), + }, + actions: { + updateLatestLog: assign(({ context }, params: { endDate: Date }) => { + if (context.latestLog && isAfter(context.latestLog, params.endDate)) { + return context; + } + + // TODO: Write back to settings + + return { + latestLog: params.endDate, + }; + }), + updateCursor: assign((_, params: { cursor: string | null }) => ({ + cursor: params.cursor, + })), + queueLifelogs: assign( + ({ context }, params: { lifelogs: LifelogsResponse }) => { + return { + lifelogQueue: context.lifelogQueue.concat( + params.lifelogs.data.lifelogs, + ), + }; + }, + ), + shiftLifelogQueue: assign(({ context }) => { + const newQueue = [...context.lifelogQueue]; + newQueue.shift(); + + return { + lifelogQueue: newQueue, + }; + }), + }, +}).createMachine({ + id: "obsidian-limitless-plugin", + initial: "querying", + context: ({ input }) => ({ + apiKey: input.apiKey, + latestLog: input.latestLog ? parse(input.latestLog) : undefined, + lifelogsDir: input.lifelogsDir, + cursor: null, + lifelogQueue: [], + vault: input.vault, + }), + states: { + idle: { + after: { + [10 * 60 * 1000]: { + target: "querying", + }, + }, + }, + querying: { + description: "Pull a page of lifelogs from the Limitless API.", + invoke: { + src: "queryLifelogs", + input: ({ context }) => ({ + apiKey: context.apiKey, + cursor: context.cursor, + start: context.latestLog ?? addDay(new Date(), -7), + end: new Date(), + }), + onDone: [{ + target: "writing", + guard: { + type: "apiReturnedLifelogs", + params: ({ event }) => event.output, + }, + actions: [ + { + type: "updateCursor", + params: ({ event }) => ({ + cursor: event.output.meta.lifelogs.nextCursor ?? null, + }), + }, + { + type: "queueLifelogs", + params: ({ event }) => ({ + lifelogs: event.output, + }), + }, + ], + }, { + target: "idle", + }], + }, + }, + writing: { + description: + "Wait for all logs to be written before requesting the next page.", + invoke: { + src: "writeLifelog", + input: ({ context }) => ({ + lifelog: context.lifelogQueue[0], + rootDir: context.lifelogsDir, + vault: context.vault, + }), + onDone: { + target: "evaluating", + actions: [ + "shiftLifelogQueue", + { + type: "updateLatestLog", + params: ({ event }) => ({ + endDate: event.output, + }), + }, + ], + }, + }, + }, + evaluating: { + description: "Evaluate next step; either querying, writing, or stopping.", + always: [ + { + target: "writing", + guard: "lifelogQueueNotEmpty", + }, + { + target: "querying", + guard: "hasCursor", + }, + "idle", + ], + }, + }, +}); diff --git a/build.ts b/build.ts new file mode 100644 index 0000000..5bbe3d6 --- /dev/null +++ b/build.ts @@ -0,0 +1,50 @@ +import esbuild from "esbuild"; +import builtins from "builtin-modules"; +import { denoPlugins } from "@luca/esbuild-deno-loader"; + +const prod = Deno.args[0] === "--production"; +const bannerContent = `/* +* THIS IS A GENERATED/BUNDLED FILE BY ESBUILD +* if you want to view the source, please visit the github repository of this plugin +*/ +`; + +const ctx = await esbuild.context({ + plugins: [...denoPlugins({ loader: "native" })], + banner: { + js: bannerContent, + }, + entryPoints: ["main.ts"], + bundle: true, + external: [ + "obsidian", + "electron", + "@codemirror/autocomplete", + "@codemirror/collab", + "@codemirror/commands", + "@codemirror/language", + "@codemirror/lint", + "@codemirror/search", + "@codemirror/state", + "@codemirror/view", + "@lezer/common", + "@lezer/highlight", + "@lezer/lr", + ...builtins, + ], + format: "cjs", + target: "es2018", + logLevel: "info", + sourcemap: prod ? false : "inline", + treeShaking: true, + outfile: "main.js", + minify: prod, +}); + +if (prod) { + await ctx.rebuild(); + await esbuild.stop(); + Deno.exit(0); +} else { + await ctx.watch(); +} diff --git a/deno.json b/deno.json index 844bc4d..c615a73 100644 --- a/deno.json +++ b/deno.json @@ -1,7 +1,7 @@ { "tasks": { - "dev": "obsideno build --watch", - "build": "obsideno build --production", + "dev": "deno run -A build.ts", + "build": "deno run -A build.ts --production", "install": "obsideno install", "uninstall": "obsideno uninstall", "bump": "obsideno bump" @@ -13,7 +13,17 @@ "DOM", "ES5", "ES6", - "ES7" + "ES7", + "deno.ns" ] + }, + "imports": { + "@formkit/tempo": "npm:@formkit/tempo@^0.1.2", + "@luca/esbuild-deno-loader": "jsr:@luca/esbuild-deno-loader@^0.11.1", + "builtin-modules": "npm:builtin-modules@^5.0.0", + "esbuild": "npm:esbuild@^0.25.1", + "ky": "npm:ky@^1.7.5", + "obsidian": "npm:obsidian@^1.8.7", + "xstate": "npm:xstate@^5.19.2" } } diff --git a/deno.lock b/deno.lock index f7dfcfd..61cbedb 100644 --- a/deno.lock +++ b/deno.lock @@ -1,7 +1,9 @@ { "version": "4", "specifiers": { - "npm:obsidian@*": "1.8.7_@codemirror+state@6.5.2_@codemirror+view@6.36.4" + "npm:@formkit/tempo@~0.1.2": "0.1.2", + "npm:obsidian@^1.8.7": "1.8.7_@codemirror+state@6.5.2_@codemirror+view@6.36.4", + "npm:xstate@^5.19.2": "5.19.2" }, "npm": { "@codemirror/state@6.5.2": { @@ -18,6 +20,9 @@ "w3c-keyname" ] }, + "@formkit/tempo@0.1.2": { + "integrity": "sha512-jNPPbjL8oj7hK3eHX++CwbR6X4GKQt+x00/q4yeXkwynXHGKL27dylYhpEgwrmediPP4y7s0XtN1if/M/JYujg==" + }, "@marijn/find-cluster-break@1.0.2": { "integrity": "sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==" }, @@ -53,6 +58,20 @@ }, "w3c-keyname@2.2.8": { "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==" + }, + "xstate@5.19.2": { + "integrity": "sha512-B8fL2aP0ogn5aviAXFzI5oZseAMqN00fg/TeDa3ZtatyDcViYLIfuQl4y8qmHCiKZgGEzmnTyNtNQL9oeJE2gw==" } + }, + "workspace": { + "dependencies": [ + "jsr:@luca/esbuild-deno-loader@~0.11.1", + "npm:@formkit/tempo@~0.1.2", + "npm:builtin-modules@5", + "npm:esbuild@~0.25.1", + "npm:ky@^1.7.5", + "npm:obsidian@^1.8.7", + "npm:xstate@^5.19.2" + ] } } diff --git a/main.ts b/main.ts index c54ab50..0781f1b 100644 --- a/main.ts +++ b/main.ts @@ -1,93 +1,32 @@ +import { Plugin } from "obsidian"; import { - App, - MarkdownView, - Modal, - Notice, - Plugin, - PluginSettingTab, - Setting, -} from "npm:obsidian"; + DEFAULT_SETTINGS, + LimitlessPluginSettings, + LimitlessSettingTab, +} from "./settings.ts"; +import { createActor } from "xstate"; +import { pluginActor } from "./actors/plugin.ts"; -// Remember to rename these classes and interfaces! - -interface MyPluginSettings { - mySetting: string; -} - -const DEFAULT_SETTINGS: MyPluginSettings = { - mySetting: "default", -}; - -export default class MyPlugin extends Plugin { - settings!: MyPluginSettings; +export default class LimitlessPlugin extends Plugin { + settings!: LimitlessPluginSettings; override async onload() { await this.loadSettings(); - // This creates an icon in the left ribbon. - const ribbonIconEl = this.addRibbonIcon("dice", "Sample Plugin", (_) => { - // Called when the user clicks the icon. - new Notice("This is a notice!"); - }); - // Perform additional things with the ribbon - ribbonIconEl.addClass("my-plugin-ribbon-class"); + this.addSettingTab(new LimitlessSettingTab(this.app, this)); - // This adds a status bar item to the bottom of the app. Does not work on mobile apps. - const statusBarItemEl = this.addStatusBarItem(); - statusBarItemEl.setText("Status Bar Text!!!!!"); - - // This adds a simple command that can be triggered anywhere - this.addCommand({ - id: "open-sample-modal-simple", - name: "Open sample modal (simple)", - callback: () => { - new SampleModal(this.app).open(); - }, - }); - // This adds an editor command that can perform some operation on the current editor instance - this.addCommand({ - id: "sample-editor-command", - name: "Sample editor command", - editorCallback: (editor, _) => { - console.log(editor.getSelection()); - editor.replaceSelection("Sample Editor Command"); - }, - }); - // This adds a complex command that can check whether the current state of the app allows execution of the command - this.addCommand({ - id: "open-sample-modal-complex", - name: "Open sample modal (complex)", - checkCallback: (checking: boolean) => { - // Conditions to check - const markdownView = this.app.workspace.getActiveViewOfType( - MarkdownView, - ); - if (markdownView) { - // If checking is true, we're simply "checking" if the command can be run. - // If checking is false, then we want to actually perform the operation. - if (!checking) { - new SampleModal(this.app).open(); - } - - // This command will only show up in Command Palette when the check function returns true - return true; - } + const actor = createActor(pluginActor, { + input: { + ...this.settings, + vault: this.app.vault, }, }); - // This adds a settings tab so the user can configure various aspects of the plugin - this.addSettingTab(new SampleSettingTab(this.app, this)); - - // If the plugin hooks up any global DOM events (on parts of the app that doesn't belong to this plugin) - // Using this function will automatically remove the event listener when this plugin is disabled. - this.registerDomEvent(document, "click", (evt: MouseEvent) => { - console.log("click", evt); + actor.subscribe((snapshot) => { + console.log(snapshot.value); }); - // When registering intervals, this function will automatically clear the interval when the plugin is disabled. - this.registerInterval( - setInterval(() => console.log("setInterval"), 5 * 60 * 1000), - ); + actor.start(); } override onunload() { @@ -101,47 +40,3 @@ export default class MyPlugin extends Plugin { await this.saveData(this.settings); } } - -class SampleModal extends Modal { - constructor(app: App) { - super(app); - } - - override onOpen() { - const { contentEl } = this; - contentEl.setText("Woah!"); - } - - override onClose() { - const { contentEl } = this; - contentEl.empty(); - } -} - -class SampleSettingTab extends PluginSettingTab { - plugin: MyPlugin; - - constructor(app: App, plugin: MyPlugin) { - super(app, plugin); - this.plugin = plugin; - } - - display(): void { - const { containerEl } = this; - - containerEl.empty(); - - new Setting(containerEl) - .setName("Setting #1") - .setDesc("It's a secret") - .addText((text) => - text - .setPlaceholder("Enter your secret") - .setValue(this.plugin.settings.mySetting) - .onChange(async (value) => { - this.plugin.settings.mySetting = value; - await this.plugin.saveSettings(); - }) - ); - } -} diff --git a/manifest.json b/manifest.json index d8feb6a..7e09390 100644 --- a/manifest.json +++ b/manifest.json @@ -1,10 +1,10 @@ { - "id": "sample-plugin", - "name": "Sample Plugin", + "id": "limitless-plugin", + "name": "Limitless Plugin (Unofficial)", "version": "1.0.0", "minAppVersion": "0.15.0", - "description": "Demonstrates some of the capabilities of the Obsidian API.", - "author": "Obsidian", + "description": "Syncs Limitless Pendant lifelogs into your vault", + "author": "Graham Barber", "authorUrl": "https://obsidian.md", "fundingUrl": "https://obsidian.md/pricing", "isDesktopOnly": false diff --git a/settings.ts b/settings.ts new file mode 100644 index 0000000..fc0bcaa --- /dev/null +++ b/settings.ts @@ -0,0 +1,57 @@ +import { App, PluginSettingTab, Setting } from "obsidian"; +import LimitlessPlugin from "./main.ts"; + +export interface LimitlessPluginSettings { + apiKey: string; + lifelogsDir: string; + latestLog?: string; +} + +export const DEFAULT_SETTINGS: LimitlessPluginSettings = { + apiKey: "", + lifelogsDir: "", + latestLog: undefined, +}; + +export class LimitlessSettingTab extends PluginSettingTab { + plugin: LimitlessPlugin; + + constructor(app: App, plugin: LimitlessPlugin) { + super(app, plugin); + this.plugin = plugin; + } + + display(): void { + const { containerEl } = this; + + containerEl.empty(); + + new Setting(containerEl) + .setName("API Key") + .setDesc("It's a secret") + .addText((text) => { + text.inputEl.type = "password"; + + return text + .setPlaceholder("Enter your secret") + .setValue(this.plugin.settings.apiKey) + .onChange(async (value) => { + this.plugin.settings.apiKey = value; + await this.plugin.saveSettings(); + }); + }); + + new Setting(containerEl) + .setName("Lifelogs Directory") + .setDesc("The directory where you want Lifelogs placed") + .addText((text) => { + return text + .setPlaceholder("Lifelogs") + .setValue(this.plugin.settings.lifelogsDir) + .onChange(async (value) => { + this.plugin.settings.lifelogsDir = value; + await this.plugin.saveSettings(); + }); + }); + } +}