feat: initial version

Working proof-of-concept

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
+> You need to own a Limitless Pendant to use this plugin!
-instead of Node.js and npm. The plugin files have been copied exactly, but the
+> This is a requirement for access to the Limitless API, which is not open to normal Limitless users at this time.
-helper functions have been moved into Obsideno, a Deno-based CLI helper for
-writing Obsidian plugins. Its functions include:
 
-- Building the plugin code using Vite instead of ESBuild directly
+A plugin for syncing your Limitless Pendant life logs to a directory in your vault.
-- 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
 
-Both this repo and Obsideno are pretty barebones, but that's what felt right for
+Since the Limitless API is a work in progress, expect this plugin to change over time.
-the moment. I just wanted to be able to make new plugins quickly.
+For now, the intended functionality is to download your lifelogs and place them in a directory.
-
-**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

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<LifelogsResponse>("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;
+    }
+  },
+);

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);
+  },
+);

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",
+      ],
+    },
+  },
+});

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();
+}

deno.json

@@ -1,7 +1,7 @@
 {
   "tasks": {
-    "dev": "obsideno build --watch",
+    "dev": "deno run -A build.ts",
-    "build": "obsideno build --production",
+    "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"
   }
 }

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"
+    ]
   }
 }

main.ts

@@ -1,93 +1,32 @@
+import { Plugin } from "obsidian";
 import {
-  App,
+  DEFAULT_SETTINGS,
-  MarkdownView,
+  LimitlessPluginSettings,
-  Modal,
+  LimitlessSettingTab,
-  Notice,
+} from "./settings.ts";
-  Plugin,
+import { createActor } from "xstate";
-  PluginSettingTab,
+import { pluginActor } from "./actors/plugin.ts";
-  Setting,
-} from "npm:obsidian";
 
-// Remember to rename these classes and interfaces!
+export default class LimitlessPlugin extends Plugin {
-
+  settings!: LimitlessPluginSettings;
-interface MyPluginSettings {
-  mySetting: string;
-}
-
-const DEFAULT_SETTINGS: MyPluginSettings = {
-  mySetting: "default",
-};
-
-export default class MyPlugin extends Plugin {
-  settings!: MyPluginSettings;
 
   override async onload() {
     await this.loadSettings();
 
-    // This creates an icon in the left ribbon.
+    this.addSettingTab(new LimitlessSettingTab(this.app, this));
-    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 adds a status bar item to the bottom of the app. Does not work on mobile apps.
+    const actor = createActor(pluginActor, {
-    const statusBarItemEl = this.addStatusBarItem();
+      input: {
-    statusBarItemEl.setText("Status Bar Text!!!!!");
+        ...this.settings,
-
+        vault: this.app.vault,
-    // 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;
-        }
       },
     });
 
-    // This adds a settings tab so the user can configure various aspects of the plugin
+    actor.subscribe((snapshot) => {
-    this.addSettingTab(new SampleSettingTab(this.app, this));
+      console.log(snapshot.value);
-
-    // 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);
     });
 
-    // When registering intervals, this function will automatically clear the interval when the plugin is disabled.
+    actor.start();
-    this.registerInterval(
-      setInterval(() => console.log("setInterval"), 5 * 60 * 1000),
-    );
   }
 
   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();
-          })
-      );
-  }
-}

manifest.json

@@ -1,10 +1,10 @@
 {
-  "id": "sample-plugin",
+  "id": "limitless-plugin",
-  "name": "Sample Plugin",
+  "name": "Limitless Plugin (Unofficial)",
   "version": "1.0.0",
   "minAppVersion": "0.15.0",
-  "description": "Demonstrates some of the capabilities of the Obsidian API.",
+  "description": "Syncs Limitless Pendant lifelogs into your vault",
-  "author": "Obsidian",
+  "author": "Graham Barber",
   "authorUrl": "https://obsidian.md",
   "fundingUrl": "https://obsidian.md/pricing",
   "isDesktopOnly": false

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();
+          });
+      });
+  }
+}