This is part of my Obsidian and Plugin REPL Cookbook

A key feature of my Obsidian setup (though not the default one!) is being able to quickly open the Obsidian window while doing other things. This allows me to do quick one-off note taking. To do this I have a global desktop hotkey which pops up the Obsidian window.

This isn’t supported out of the box but is provided by the Tray Plugin. To install this go to settings (Ctrl + ,) then community plugins, enable community plugins, search for the tray plugin, and install it then enable it. If you go to its settings (again in settings Ctrl + ,) you will find it has a setting for Toggle window focus hotkey.

Tray works pretty well. At the time of writing it has one bug where if you reload Obsidian (which can be quite common when developing plugins) it creates multiple icons in the tray and the hotkey stops working. You can fix this by exiting Obsidian and starting it again. Because of this - and because I tend to have hotkeys to switch between apps in general I use a different approach on linux - but this requires you to use linux and have a bit of command-line knowledge. So if you aren’t doing plugin development Tray should work fine.

This is part of a cookbook on Obsidian and Plugin REPL plugin in the section on configuring basic Obsidian. You might like to look at other recipes.

I am not affiliated with Obsidian. I am the author of Plugin REPL

It is possible to do JavaScript scripting in Obsidian in various ways (including using my plugin, Plugin REPL) and this can do a lot of things. However, for some more complicated tasks it can be nice to use libraries that other people have created, which tend to be uploaded as an NPM library. Because of how Obsidian works - even though Obsidian has its own npm modules provided in a node_modules directory you cannot add to these modules. A work around is needed.

How plugins do it

One approach is to use a plugin. The way that plugins work is use a JavaScript bundler to include the source code for modules in the main.js that a plugin provides. This plugin can then provide access to this module - although it normally uses it internally. A nice trick here is to use the following syntax in TypeScript:

import * as name from 'name'
...
this.name = name

You can then hang name of your plugin, and then get access to it from Obsidian using:

app.plugins.plugins["my-id"].name

If you just want something that works

However, you probably don’t want to create your own plugin every time you use a library. If you are doing your Obsidian JavaScript scripting with Plugin REPL then plugin repl provides a system to use plugins, plugin REPL imports. With this you can: check out a repo, add the NPM library to a list, run a command, and then you can use a funciton replRequire to get at the NPM library.

You can likely do something similar with user scripts in Templater.

Finishing up

I hope this is useful. If you found this intereting I might suggest you:

1. Have a look at some more recipes in my Obsidian cookbook

2. Read about scripting in Obsidian.

3. Read my somewhat academic review of note taking in Obsidian.

You can also follow me on X, where I write about various things, or follow my blog where I mostly write about tools for reading and research.

I use properties as a form of typed link in Obsidian which I then use to create automated maps of content. This all works pretty well but the inline typed links can be a little ugly and detract from the flow of a note.

up:: [[Parent]]

You could instead add this as a property to the beginning of the note but this can require too much clicking for those used to being able to do everything with a keyboard.

This is the sort of problem well suited to my plugin Plugin REPL where you can use a dash of JavaScript to make your life easier.

If you execute the following snippet using Plugin REPL (after installing it) - by highlighting the code and running Plugin REPL: Execute the current line or selection

newCommand(function frontmatter_property(){
	const [name, newValue] = lineAtPoint().split(/ *:: */)
	if (!newValue) return
	const old =  view.metadataEditor.properties[name]
	if (view.metadataEditor.properties.filter((x) => x.key === name).length === 0) {
		view.metadataEditor .insertProperties({[name]: newValue})
	} else if (Array.isArray(value)) {
		view.metadataEditor.insertProperties({[name]: [...old, newValue]})
	}  else {
		view.metadataEditor.insertProperties({[name]: [old, newValue]})
	}
	killLine()
})

You can then use the command Plugin REPL: frontmatter property to move an inline property to the frontmatter at the beginning of the file.

If you find this useful - you can run it every time Obsidian starts by adding it to your repl.md file.

I did this using my plugin Plugin REPL, but there are other ways to run JavaScript which you could use to adapt this script.

This is part of a cookbook of useful things you can do in Obsidian and with Plugin REPL (of which I am the author).

If you find this interesting and useful you might like to:

1. Read this page about how to make half-automated maps of content in Obsidian.

2. Read this somewhat academic review of note taking in Obsidian.

3. Look at some of the other Obsidian tricks.

You can also follow me on X or my blog.

When inserting notes in Obsidian I often want to both build a web of links between articles as well as maintain a Map of Content. Because I do this a lot, it can start to feel like a bit like a stream of continuous paper cuts if . The completion on link insertion with [[ helps. But another thing that can be useful is inserting links based upon your history.

For these snippets you first need to install the Pane Relief plugin.

This snippet in Plugin REPL helps by either inserting a link to the previous note in your history.

newCommand(function link_history() {
	let stack = view.leaf["pane-relief:history-v1"].stack
	let pos = view.leaf["pane-relief:history-v1"].pos
	insert("[[" + stack[pos + 1].path.replace(/\..*/, "") + "]]")
})

If you have installed plugin REPL you can paste it anywhere and then execute it with Plugin REPL: Execute the current line or selection . Then if you like it you can add it to plugin REPL’s repl.md startup file.

Looking at the last few files

Sometime sit can be useful to insert a link to the file in the recent history. You can use a snippet for this.

newCommand(async function link_history_select() {
	let stack = view.leaf["pane-relief:history-v1"].stack
	let pos = view.leaf["pane-relief:history-v1"].pos
	let path = await fuzzySelect(stack.slice(pos +1, pos + 10).map((x) => x.path))
	insert("[[" + path.replace(/\..*/, "") + "]]")
})

Shortcuts

After executing this code you can run this from the command palette or create a shortcut. I use Ctrl-Alt-L and Ctrl-Alt-Shift-L.

You don’t need to use Plugin REPL

I wrote Plugin REPL and find it useful. However, you could adapt these scripts for Templater or Dataview.

Finishing up

I hope you found this interesting. If you did you might like to read about

1. The trade off between automated and hand-crafted maps of content

2. My review of how people take notes in Obsidian.

3. Automating processes with Obsidian

I am readwithai. I make tools related to reading and agency sometimes to do with Obsidian and write about this. I am the author of Plugin REPL

If this sounds interesting you can follow me on X or read my blog.

Plugin REPL is a tool I wrote for easy in-editor scripting for Obsidian. In many of the tips and tricks here I use Plugin REPL because it is easy - that’s why I wrote it!. However, you don’t need to use Plugin REPL and it feels a bit wrong to offer no alternative. Rather than explaining the alternative to Plugin REPL, in every post (which takes quite a bit of typing because the alternatives are a little involved), I’m going to do it once here.

Plugin REPL is just JavaScript with some convenience functions. There are other tools that give you access to JavaScript.

Dataview

If you are just doing something on one page. Then dataview may be one approach. An issue (which at times is a benefit) with dataview is that it frequently reruns the script in a Dataview block whenever code changes. Another issue is that dataview does not allow you to run scripts on startup - for this you can user user scripts and templater - but this prevents you from doing everything from with Obsidian.

Nevertheless, you often want to do things on just one page and dataview can work well for this

Plugin REPL is more designed to do things once in Obsidian when you say so. However, what you can do in dataview is create a button or command that you can press once.

This snippet creates a button that prints a message.

```dataviewjs
function click() {
	new Notice("hello")
}
let button = dv.el("button", "hello", {"onclick": click})
```

You will need to do a little work adapting objects and plugins from plugin REPL, as described here.

You can also add commands to the dataview plugin object from within dataview and then set keybindings.

```dataviewjs
let plugin = app.plugins.getPlugin("dataview")
plugin.addCommand(
{
            id: 'say-hello',
            name: 'Say hello',
            editorCallback: (editor, view) => {
                new Notice("hello")
            }
        }
)
```

This command will be added to Dataview’s commands. A downside of this approach is that you need to open the page with this snippet before this snippet will be defined.

Scripts that run on startup

Plugin REPL can run scripts on startup that can define commands. Dataview can’t really support this (apart perhaps from having a daily note with dataview components) However, this can be achieved with Templater and scripts. This requires a bit of setup and the use of an external editor.

After installing Templater, you can go to the “User script functions” settings in Templater.

Then in another editor you can edit .js files in $VAULT/scripts .

If you create a file call hello.js in $VAULT/scripts:

function loadHello (app) {
       app.plugins.getPlugin("templater-obsidian").addCommand({  
               id: "say-hello-templater",  
               name: "Say hello with templater",  
               editorCallback:  (editor, view)  => {  
                        new require('obsidian').Notice("hello")
               }  
       })  
}

module.exports = loadHello

You can then add a “startup template” that calls this function

Then add the following script in templater-startup.md

<% tp.user.hello(app) %>

Obviously this has a lot of moving parts, each of which can wrong and each of which can be difficult to debug without proper output. In Plugin REPL you can get bugs in repl.md file - but then you can rerun it line by line by hand. You can rerun all of templater-startup.md from the command panel with Templater: Open insert template modal.

Getting hold of objects and functions

Plugin REPL gives you access to various useful pieces of state as well as convenience functions.

You can view the source code for the convenience functions to reimplement them outside of Plugin REPL or potentially just copy them.

To get access to the state you can use the following snippet:

editor = app.workspace.getLeaf().view.editor
view = app.workspace.getLeaf().view

Finishing up

I hope this was interesting, and perhaps shows what Plugin REPL is good for. You might like to:

1. Have a look at some more recipes in my Obsidian Cookbook.

2. Read about scripting Obsidian

3. Read about "reading broadly defined” which is part of my interested in this blog

I am readwithai. I am making tools in related to reading, broadly defined, and productivity, sometimes around Obsidian.

You can follow me on X or my blog.

Sometimes you want to keep track of your progress on a task or project in Obsidian, which you might represent with a note. One approach is just to dump your thoughts into the note tag it with a timestamp or date (possible with the help of DatePicker) and tidy up later. However, if you note is quite long this can be start to be a pain particularly as you have to jump around to find your progress updates… and it can be nice to keep things neat.

One approach that I’ve used is to have a button in your note to create a child note, which you track with a dataview query.

I use the following meta bind button which I created with its fancy builder.

```meta-bind-button
label: Progress
icon: ""
hidden: false
class: ""
tooltip: ""
id: ""
style: default
actions:
  - type: templaterCreateNote
    templateFile: progress-reports/create-progress-report.md
    folderPath: /
    fileName: ""
    openNote: true
    openIfAlreadyExists: false
```

This then uses a Templater template to create a note with the date in the title and a tag.

<% await tp.file.rename("Progress on "+ tp.date.now("YYYY-MM-DD"))%>
<% tp.file.cursor() %>

#progress-report

Then I also have a Dataview query in the note to track a task:

```dataview
LIST FROM #progress-report
```

I found someone doing something similar (with a more complete script) on reddit.

I am @readwithai. I’m creating tools related to reading and productivity sometimes in Obsidian. Follow me on X or subscribe to the blog:

Subscribe now

:

I have started using Obsidian: it’s a fun note taking app that lets you build your own “web” of knowledge sort of like Wikipedia. This note is about using Obsidian better but if this makes no sense and you are still interested you might like to start here.

When you start making notes on a topic you often don’t know what structure you should have in your knowledge base to store them, so it can be convenient to quickly add a tag or a parent to a note so your notes have a bit of structure. You also don’t necessarily want to be distracted from the note that you are taking by maintaining structure. For this sort of thing, automated maps of content can work well, and are fairly straightforward to create with a saved dataview template like so:

```dataview
LIST WHERE contains(parent, this.file.link)
```

However over time it can be good to actually make these maps of content more “hand-crafted”. By hand-crafted I mean a map of content in which you have created the links by hand. The notes are then often ordered better, so that similar links are together and you have been made to think about how these ideas relate to one another. Also every time you look at this hand-crafted MOC you will remind yourself of this ordering and the process of making it.

One nice way of creating these handcrafted maps of meaning is to have a little sentence like the first paragraph in Wikipedia. It might looks something like this

Node is a [[runtime]] for the programming language called [[JavaScript]]. It funs on the server and can [[extensions written in C]]. It also supports [[JavaScript imports|imports]]

Going from automated MOCs to hand-crafted MOCs

An approach I have found of slowly moving between automated MOCs and hand-crafted maps is to have a dataview query at the end of your notes of all the child notes of your note that have not been manually added to a note (or a child note). This can be done with this query:

```dataview
LIST WHERE contains(parent, this.file.link) AND !contains(this.file.outlinks. file.link)
```

I then put this at the bottom of my MOC. Over time and when I think I understand the structure enough. I can add these links to the handcrafted part of a note and the links disappear.

A bit about the rule of seven

One thing you might like to do when you have too many notes with the same parent is add child “structure” notes to keep your links, so that you have a tree of notes. There is an idea that humans can hold between 5 and 9 things in working memory at the same time, so having around 7 links in each note in your map of content can work well. Of course, sometimes it good to have a nice long list as well

You can still output the complete tree under a top node with the following code:

```dataviewjs
function contains(property, link) {
	if (property === undefined) {
		return false
	}
	if (property.hasOwnProperty("0")) {
		return property.map((x) => x.path).contains(link.path)
	}
	return property.path == link.path
}

function children(p) {
	return p.file.inlinks.filter((x) => contains(dv.page(x).parent, p.file.link))
}

function makeTree(root, depth) {
	if (depth == 0) {
		return root.file.link
	}
	return [root.file.link, children(root).map((x) => makeTree(dv.page(x), depth - 1))]
}

dv.paragraph(makeTree(dv.current(), 2))
```

Finishing up

I hope you find this idea useful. If you are interested in this sort of thing you might like to:

1. Look at my review of note taking in Obsidian

2. Read my page on automated maps of content in Obsidian,

3. Look at my cookbook of tips and tricks for Obsidian.

You can also follow me on X where I post about various things. Or subscribe to my blog where I mostly write about research and reading with Obsidian.

Bibliography

Also linking your thinking has a lot of ideas about how note taking and thinking interacts

Subscribe now

A map of content might like something like:

# Wars

* [[ World war 1]]

# World war 1

* [[Battle of the Somme]]

# Battle of the Somme

Some details about the battle

The key thing is that the notes in your maps of content are mostly about linking to other notes - though they can have a little bit of information.

One upside maintaining maps of content is that it can acts as tool to help you memorize your content through repeatedly exposing you to it.

Read more about this in this blog post.

I am readwithai. I am making tools for reading (amongst other things), sometimes using Obsidian.

If you are intersted in this you might like to read my Review of note taking in Obsidian.

Note that this is a duplicate post for reddit because I need to change the thumbnail.

You can follow me on X on subscribe here.

Subscribe now

There’s a long forum post on the Obsidian forums talking about how typed links might be represented in Obsidian. None of the ideas there have been implemented really - but the approach presented here using Obsidian properties work well.

How to represent typed links in Obsidian

One way to represent a typed link between one Obsidian note and another is to use a property. You can either represent this within your note using the :: syntax, like so:

parent:: [[Parent Note]]

A nice thing about this syntax is that you can add it anywhere in your note. A downside is that you can’t cleanly embed this syntax within a paragraph of text link you can with normal links. One approach is to place your types links like this after a paragraph like so:

A cat is a type of [[Mammal]] which hunts [[Mice]].
hunts:: [[Mice]]
typeof:: [[Mammal]]

You can also add a property to the frontmatter of your note using the [[syntax inside a property.

You can have more than one parent or more than one link

I’ve found that having more than parent for a node can be quite useful particularly as nodes become more general. For example, a topic might be relevant for a particular project, documentation and an overarching goal. For other forms of relations, it’s very natural to have multiple links.

With the breadcrumb :: syntax you can repeat the same “link type” multiple times in your note

parent:: [[Plan for next week]]

More writing...

parent:: [[Evergreen note 1 ]]

If you are using properties you can set the property type to a list and then add multiple links with [[.

Using typed links

But what’s the use of these properties. The first think you can do is click on them with a mouse! You can also add them Obsidian’s graph view using the useful Graph Link Types plugin by Frisch.

I also often create dataview property queries to create Automated Maps of Content as part of my maps of content, with the following query:

```dataview
LIST WHERE contains(parent, [[Current Node]])
```

Here contains work both if a node has a single parent or multiple parents.

You can create a Templater template for this like so:

```dataview
LIST WHERE contains(parent, [[<% tp.file.title %>]])
```

Finishing up

I hope that was useful or interesting. If it was you might like to:

1. Read my page about how to automated maps of content in Obsidian.

2. Read my slightly academic review of note taking in Obsidian.

You can also subscribe to this blog where I write about reading and Obsidian, or follow me on X where I write about various thinks - but sometimes Obsidian.

Subscribe now

One way to do this is through reading the documentation, or looking at the source code that plugins use to bind to Obsidian. You could also browse the forum, which contains various snippets or ask questions there.

However, one problem is that many of the methods available on the app object are not documented, yet are necessarily to do what you want to do, and are in fact at times used by plugins in practice to get their job done. Examples are interacting with commands and plugins. Also it can be good to “experiment at bit” while coding by interacting with these the app Object directly.

Using the Developer console

You can get at a developer console (like a browser uses) by pressing Ctrl+Shift+I. This has a “Console” tab which you can use to execute JavaScript - and has access to an app object. The shell is quite slick - since lots of people use JavaScript. It has completion with fuzzy search and previews values. When you have an object it displays it in a way that lets you collapse and expand different variables

Using Plugin REPL (of which I am the author)

You can also install Plugin REPL a tool for in-editor scripting that follows some of the norms of the venerable Emacs editor, to execute JavaScript expressions from within an Obsidian note. This has a couple of benefits - it permanently keeps your history, and allows you to copy and paste results, and can be quite good for “building up expressions”, and generally one is a bit more “free” outside of a the single line of a prompt.

To list the properties on an object you can use dir(app) or to get a fuzzy selector listing values you can use fuzzyDir(app).

You can also use this snippet to “complete” properties on app.

Here’s a demo:

I am readwithai. I make tools and write about things related to reading and productivity in Obsidian. If you liked this post you might be interested in my cookbook of things you can do in Obsidian and Plugin REPL. Or, if you are feeling in an “academic mood” perhaps you want to read my review of note taking in Obsidian.

Follow me on X. Follow my progress and thinking on my blog.

Plugin REPL in Obsidian lets you script obsidian with JavaScript directly within Obsidian. A common thing to want to do is explore objects to work out how you can use this. Plugin REPL provides a dir and fuzzyDir method for this purpose:

dir(app)
fuzzyDir(app)

However, after a while I got bored to typing this. I could have added dot completion like an editor to Plugin REPL, but plugin REPL doesn’t quite “own” dot in Obsidian - because you can write and execute code anywhere with Plugin REPL.

Instead I quickly hacked up a couple of commands so that I could have a hotkey for looking up and inserting attributes.

newCommand(async function fuzzy_dir_line() {

let attr = await fuzzyDir(eval(lineAtPoint()))

endOfLine()

if (! isNaN(attr)) {

insert("[" + attr + "]")

} else {

insert(".")

insert(attr)

}

})

newCommand( function delete_back_to_dot () {

let end = point()

backwardRegexp(/\./)

kill(point(), end)

})

Then I bind some hotkeys to these.

Here’s a demo of this working.

This is part of a cookbook of cool things you can do with Obsidian and Plugin REPL.

I am @readwithai. I make tools in Obsidian related to productivity, agency and reading and write about them. If that sounds interesting you can follow me on X or substack.

Subscribe now

Obsidian is at its core an extensible markdown editor. You can extend it with plugins, but sometimes there is no plugin to do what you want, often because your tasks is quite specific to what you are trying to do. I wrote Plugin REPL to help you quickly script Obsidian for some tasks.

For this, you might want to do a tiny bit of scripting. From my perspective there are three sorts of thinks you might want to automate in Obsidian.

• Content that gets generated based on content you have already made

• Templates

• Code that you want to run from the Command Palette or hotkeys

Generated content

For this you tend to want to “embed” the code to generate the content into your page. People tend to use dataview for this. Dataview has two languages - a query language inspired by SQL and JavaScript language for more general scripting.

Here is a query which outputs all nodes with two tags.

```dataview
LIST from #howto AND #javascript
```

This can be good to add to “index / structure notes” to index other notes.

JavaScript queries can do more complicated and dynamic things. For example the query below returns the number of pages with identically tags to the current page.

```dataviewjs
let pageTabs = dv.current().tags
let matchingQuery = "LIST FROM " + pageTabs.map((x) => "#" + x).join(" AND ")
let result = await dv.query(matchingQuery)
dv.paragraph(result.value.values.length)
```

A thing to bear in mind about this code is that it is reexecuted when you reopen the page or when things change so it should not have side effects. For example, you for sometihng like a command you might want it to prompt for text.

Templates

It is quite common to want to generate content in a consistent form (potentially depending upon custom values and insert it into your document). Templater is a good tool for this.

Custom Commands

If you want to run a command that can do things and that you call often (such as creating new notes, or inserting them into your document) then you can use Plugin REPL.

Here is a command to insert the current timestamp in Plugin REPL.

newCommand(function insert_timestamp() {
	insert((new Date()).toISOString())
})

People also have used Templater templates to for “commands” since when executed they can run javascript code which can have side effects. If you have more complicated functionality or want to share your code you might want to write your own plugin.

This is part of a cookbook of things that you can do with Obsidian and Plugin REPL. If you found this interesting you might like to read some other pages I might looking at some examples of thinks you can do by automating Obsidian, such as this timeline of twitter posts.

I am not afilliated with Obsidian, I am the author of Plugin REPL. I am @readwithai - read about me here.

A common thing that you want to do in Obsidian, especially when starting out, is to search Obsidian’s community plugins to see if there a plugin to help you with your current task. In practice this is a few clicks away: you have to open the settings, find community plugins, click the tab, then go to the search box. What would be cool would be to have a keybinding to jump straight to search.

How to code this up

Writing Obsidian plugins is interesting, plugins start off very “API’y” by defining callbacks using Obsidian API but then when you start defining a user interface they can turn into website coding using JavaScript, HTML and the document object model. I’ve found that sometimes to automate things, I almost start doing “screen scraping” because there is no API for what I want to do.

This is what I had to do to implement this, but I did have to do that much screen scraping - just find a browse button a click it. Here is custom command in Plugin REPL will open the Community plugins settings page and then find the button with “Browse” written in and click it. (Note that I’m the author of Plugin REPL)

newCommand(async function open_community_plugins() {
	await openSetting("Community plugins")
    document.evaluate('//button[text()="Browse"]', app.setting.containerEl).iterateNext().click()
})

This uses the document.evaluate method of the standard JavaScript document object model.

Once you’ve written this command you can evaluate it with Plugin REPL and optionally add it to your repl.md startup file.

Demo

The old fashioned Templater way

You don’t have to use Plugin REPL for this - although it makes things easy if you do. Instead you could use Templater by creating the following plugin in your template directory called plugins.

<%* 
	tp.app.setting.open()
	await tp.app.setting.open()
	await tp.app.setting.openTabById(tp.app.setting.settingTabs.filter((tab) =>  tab.name === "Community plugins")[0].id)
	document.evaluate('//button[text()="Browse"]', app.setting.containerEl).iterateNext().click()
%>

You can then add this template as a command under Template hotkeys in Templater’s settings.

And then define a hotkey for the Insert command. This approach is a bit more effort to debug (Templater doesn’t give particularly useful error output). Also Templater does not really support assignment - hence the inlining of tp.app.setting.openTabById(tp.app.setting.settingTabs.filter((tab) => tab.name === "Community plugins")[0].id).

But it does work!

P.S You could also use Quickadd to add a script (which does not have the limitations that Templater has) - also templater supports user script. Both approaches involve using another editor and a fair amount of clicking.

Finishing up

I hope you found that useful. I enjoy using this keybinding and it makes installing plugins more fun. If you found this page interesting you might like read.

1. This page about some useful hotkeys I used in Obsidian (including this one)

2. This page about automated maps of content using dataview

3. This kind of academic summary of note taking in Obsidian that I made

Also you can follow me on X or substack if you like.

Interesting? The is a whole “Cookbook” here of similar Obsidian tricks. Also I am creating tool in Obsidian, some of it for automated reading. If you are interested maybe check out the blog.

I am not affiliated with Obsidian. I am the author of Plugin REPL

I like to plan the things that I am going to tweet on twitter in an Obsidian note. That way I can avoid either spamming people too much or note saying anything at all. Whenever I have something I want to share with the world I open an Obsidian note and then note it down. Then at a later time I add a timestamp of when I want to send it and send it.

I felt a little nerdy and decided I wanted a timeline of the tweets I had sent so decided to hack up a timeline for this. Obsidian has a couple of tools for timelines but they weren’t quite what what I wanted. Obsidian has native support for timelines with a the diagramming domain specific language mermaid - but the boxes on this were a bit too big and the timeline didn’t have a continue time axis. There is a plugin for it - but the plugins wanted to read dates from notes whereas I had lines labelled with times.

So as I was already using a little JavaScript code in Plugin REPL to get out the times of all my tweets I decided to use the JavaScript library vis. Plugin REPL has features to import JavaScript libraries, so I used that to pull in vis after installing it.

vis = replRequire('vis')

Then I have the horrible following expression to parse out dates.

var lines = bufferString().split("\n").filter((x) => return  x.startsWith("~~202") ).map((x) => [x.split(" ")[0].replace(/~/g, ""), x.split(" ").slice(1).join(" ").replace(/~/g, "")]).sort()

I should probably split this up. But it basically gets all the struck through lines that start with a date and then gets rid of the striking and splits the date from the rest of line .

Then I used the following Plugin REPL code block

```plugin-repl
var data = lines.map(([x, y]) => ({start: x, content: ".", id: x}))
var lineById = Object.fromEntries(lines)

dataset = new vis.DataSet(data)
timeline = new vis.Timeline(el, dataset, {})

var currentItem
timeline.on('mouseOver', function (properties) { 
if (properties.item === null) {
	return
}

if (properties.item != currentItem)
	message(lineById[properties.item]);  

currentItem = properties.item
});

zoom = document.createElement("button")
zoom.appendText("zoom")
zoom.onclick = (() => timeline.zoomIn(1))

unzoom = document.createElement("button")
unzoom.appendText("zoom out")
unzoom.onclick = (() => timeline.zoomOut(1))

el.appendChild(zoom)
el.appendChild(unzoom)
```

To draw the graph, the el variable is an html element that gets drawn after the code runs. I tell vis to render into this element and then add a couple of buttons with appendChild to zoom in and out. I use message to display a tweet’s text when I mouse over it in the timeline.

I can then see when I should post tweets to avoid spamming people too much and look at what I am posting about to avoid changing the topic too much.

One interesting plugin that was drawn to my attention after writing this was the chronos plugin. The documentation for this suggests generating a chronos code block from a a (dataview) code block in order to produce dynamic timelines.

This is part of my Obsidian and Plugin REPL Cookbook where I give examples of how to make Obsidian do various useful things. I am generally interested in making tools for Obsidian and particularly targetting tools for reading. If you are interested you can subscribe on substack or X.

I am not affiliated with Obsidian. I am the author of Plugin REPL

Obsidian+PR Cookbook - 𝕏 - YouTube - Official Obsidian Docs

Plugin REPL provides a convenience functions to do a lot of the normal things you would do while editing Obsidian allowing you to automate various tasks. But at some point you might find yourself wanting to do something complicated or something graphical and there might be JavaScript libraries that magically do want you want.

Plugin REPL provides a means of using third-party JavaScript code inside Obsidian - similar to how plugins using the replRequire method but this takes a little work and requires you to know a little bit amount the command line.

How this works

You need to check out a “library installer” into your vault with git. Then install the libraries you want there. Then Plugin REPL can find them when you run replRequire(“LIBRARY”) .

To install libraries you first checkout this github repository into your vault directory with:

git clone git@github.com:talwrii/plugin-repl-imports.git

Then you edit the imports.txt file in this directory to add the libraries that you want.

Then you fetch the libraries you want with

cd plugin-repl-imports; npm run run

Then you can import them in Obsidian.

I am not affiliated with Obsidian. I am the author of Plugin REPL

Using Plugin REPL involves writing some code in a language called JavaScript. Other commonly used Obsidian plugins like Dataview and Templater make use of JavasScript (Dataview also defines it’s own programming language). Programming is a skilled and often complex activity that some people spend their entire lives working on. But I am going to argue here that a little JavaScript can go a long way and you don’t need to learn all of it.

So firstly, you probably don’t need to understand that much to do the things that you want to do. I will give a summary of some of the things that you need to know here. JavaScript can be used to buid complex things, so have a bunch of complex features to handle the complexity but you don’t need this, but to get started with Plugin REPL you need a lot less

Why program anyway

Why program at all? You can do lots of things in Obsidian without programming. And there are many plugins that let you do things.

The value that programming provides is the ability to do similar things slightly differently by clicking together parts. Often plugins will only let you do things in one way.

Programs also allow you to express what you want to do in text, which can at times be a lot simpler than updating all the settings for Plugin.

The basics of JavaScript

Firstly, you may well need to understand no JavaScript to use JavaScript - you can find the pieces of code that you need to do what you want to do and copy and paste them into Obsidian. Alternatively, you might be able to find example code and adapt it slightly to do what you want.

If you need to actually create something new, the main thing that you need to be able for Plugiun REPL is call functions (Plugin REPL provides you with a lot of functions to do things), collect informtion from functions, and use variables.

Functions

To use/run/call a function called myFunction you add a pair of brackets like so:

myFunction()

Sometimes the function needs some information. You can provide this information inside the brackets with commas separating each value:

myFunction(1, 2)

Sometimes you will want to provide this function with a piece of text, this text has to go in quotation marks.

myFunction("The quick brown fox jumps over the lazy dog")

Getting information from a function

Sometimes a function can give you information about what it has done. This is called the result of the function. You can save the result of the function in a variable. To do this you use the equals symbol like so

result = myFunction()

If you you are creating more complex programs there are more “correct” ways of doing this - but you can worry about them later.

Using the information from a function

Once you have collected information from a function you can use it in a function like so:

otherFunction(result)

Plugin REPL also provides some “default” pieces of information such as path.

Other things

That’s basically it for the javascript you need. Everything is calling functions and combining the results. But there are a couple of other things you need. If you want to create a command you need to use the following code

newCommand(async function() {
 ... functions go here
})

The other complexity is that some functions start and “run in the background” if you want to collect information from them you have to “await” the reply like so.

a = await promptString()

This is a little confusing, but it is done so that in complicated programs you can do things at the same time.

Even more

So if this is all you need why does JavaScript have more features. The way I think about it is that everything else is about “dealing with the complexity” of writing larger programs. If you want to do more complicated things you might need to learn these.

The first thing it would use useful to learn about are methods. These are functions that are “attached” to a piece information. You use them like

result = a.f()

This is like saying result = f(a) but f is attached to a so you can use it on a. This makes things a bit “neater”. An example of when you might want to use this is on the dv object:

dv = getDv()
dv.pages()

To learn this you might like to get a book on JavaScript or look at examples and try to understand what the code is doing.

I would suggest you learn things in this order.

• functions

• arrays

• filter and map

• the “.” in javascript

• async functions

• Everytthing else.

• Google what you are trying to do.

What next

I hope this is enough of an introduction on JavaScript that you could use it for some features of Plugin REPL. You might like to check out some examples of cool things you can do in the cookbook for inspiration.

I am not affiliated with Obsidian. I am the author of plugin repl

I like snippets. Snippets works by replacing a word that you just typed with a piece of text. I like snippets so much that I defined my own snippet library for zshell.

Much as organizing as you go is a key part of using Obsidian, I’ve found that defining snippets as you go is a good way of actually getting around to creating snippets. Obsidian has a plugin for snippets called Text Snippets that works well enough but defining new snippets was just a bit too much effort for me to make it “automatic”. Fortunately a little tweaking with Plugin REPL got me what I wanted - although the solution involved a little more "magic” that I would like.

I defined the following two commands, which I developed within Obsidian itself.

newCommand(async function expand_or_create_snippet () {
    let before = lineAtPoint()
    command('text-snippets-obsidian:text-snippets')
    if (before != lineAtPoint()) {
	return	
    }
    let name = wordAtPoint()
    await openSetting("Text Snippets")
    let el = document.evaluate("//*[text()='Text Snippets - Settings']/ancestor::div/descendant::textarea", document).iterateNext()
    let replacement = await promptString()
    el.value = el.value +"\n" + `${name} : ${replacement}`
    el.dispatchEvent(new Event("input"))
    app.setting.close()
    command('text-snippets-obsidian:text-snippets')
})

newCommand(async function open_snippet_settings() {
    openSetting("Text Snippets")
})

The first command command

1. Tries to expand a snippet

2. If it fails to expand then it open the settings

3. Find the textbox to in the snippets plugin where snippets are defined

4. Prompts for a new snippet and inserts it into the textbox

5. (Slightly magic) ensures that Obsidian detects that the value has changed

6. Closes settings and expand the snippet

The second command open the settings for if I want to change snippets.

Here is an example of the commands in use.

This will probably be enough for me to use now. I may well define some commands to change snippets later - and I might end up just removing text snippet entirely since the functionality provided is quite simple. I might even end up using Templater templates instead. But it’s good enough for now - which is one of the philosophies of organize as you go.

Regardless, this is an example of the more hacky things that you can do with Plugin Repl.

This page is not affiliated with Obsidian. I am the author of Plugin REPL

When working in Obsidian in can be natural to “organize as you go”. One natural thing to want to do is right things in one note - then decide there is too much detail and create a new note with a region - and it can be helpful if this as simple as possible.

This is the sort of thing that is easy in Plugin REPL . If you execute the following code in plugin repl:

newCommand(async function send_selection_to_file() {
	let filename = await promptString("File to send selection to:")
	await writeFile(filename, selection())
	kill()
	insert(`[[${filename}]]`)
})

then you will have a command to send a region to a new file that you can run form the

You might also like the Note Refactor plugin, which provides similar functionality.

I am not affiliated with Obsidian. I am the author of plugin repl

Obsidian++ Cookbook - 𝕏 - YouTube - Official Docs

At it’s core Obsidian is a markdown editor with commands that get bound to hotkeys and plugins that can add commands (with the slight caveats that some of these commands can render HTML with javascript events!). This philosophy is quite similar to Emacs.

To run a command in Obsidian you can use the command palette that is usually run with Ctrl-P . This allows you to search for commands by their names and then run them.

If you use a command a lot of the time you can define a hotkey by going to the settings (you can get to them from the command palette! or ctrl-,) then if you find the the hotkeys section you can define keys. I find myself defining hotkeys quite a lot so I have defined a key binding to jump directly to hotkeys.

Sometimes it can be difficult to remember hotkeys or you can run of them. I use Sequence Hotkeys plugin for this. I then have precises like Alt-D for bindings related to learning Danish in Obsidian.

I am not affiliated with Obsidian I am the author of plugin repl

Emacs and Org mode are to some degree the "original” extensible test editor and personal knowledge base. It is unclear the extent to which Obsidian was influenced by these tools. Emacs will have influenced many of the tools that exist in the world which in turn with have influenced the Obsidian designers (potentially via VS Code). Wikipedia is clearly another influence.

A downside of Emacs is that it not necessarily that easy to use for “non-programmers” whereas Obsidian is more discoverable and easy to use. That is why I use it. But you can can inspiration from Obsidian.

Plugin REPL is inspired by the ability to quickly evaluate code to hack up features in Obsidian.

I am not affiliated with Obsidian. I am the author of plugin repl