Workflow: Using Zk to Manage Meeting Minutes

[pkazmier]

Overview

I find that the majority of my note taking these days are those from recurring meetings. This includes weekly staff meetings, plethora of agile meetings, and "one on one" meetings with numerous people. I have recently discovered zk and zk-nvim, which has enabled me to migrate from Emacs and org-mode to a Neovim / zk workflow. I'll briefly describe some of my customizations I've made and how it fits into my workflow in case others might benefit.

Assumptions

This workflow assumes one keeps all of their meeting notes in a separate folder within their zk notebook. I use a folder called meetings to keep all of my meeting notes separate from the rest of my zk notes. In addition, I have created a zk group for this meetings folder with a custom note template (below). The template contains a tag called #meeting and a title in the form of YYYY-MM-DD: Meeting Name.

# {{date now "%Y-%m-%d"}}: {{title}}

{{content}}

#meeting

ZkMeeting

I created a new zk-nvim command called ZkMeeting, which will open a Telescope picker that displays the unique names of your meetings—without the prefixed date. So, if you have weekly staff meeting notes with the following titles:

• 2022-10-01: Staff Meeting
• 2022-10-08: Staff Meeting
• 2022-10-15: Staff Meeting

Then Telescope will include "Staff Meeting" in a picker window. If you select that item, a new note is opened with that meeting name passed as the title. With the template above, a new note is created that looks like this:

# 2022-10-22: Staff Meeting


#meeting

If you are having a meeting for the first time, in the picker, you can type the name of the meeting and press C-e, which will create a new meeting note with that name (similar to the behavior on the interactive zk edit -i on the command line.

Here is where I define the ZkMeeting command:

      require("zk.commands").add("ZkMeeting", function(options)
        options = vim.tbl_extend("force", { dir = "meetings" }, options or {})
        require("user.utils").new_meeting(options)
      end)

Here is the relevant part of my user.utils module referenced in my command above:

function M.new_meeting(options)
  local zk = require "zk"
  local api = require "zk.api"

  options = vim.tbl_extend("force", { select = { "title" }, tags = { "meeting" }, regex = "^%d+%-%d+%-%d+: (.-)$"}, options or {})
  api.list(options.notebook_path, options, function(err, notes)
    assert(not err, tostring(err))
    assert(#options.select == 1, "options.select must contain one element only")
    local names = M.meeting_names(notes, options.select[1], options.regex)
    M.show_meeting_picker(names, options.telescope, function(name)
      zk.new(vim.tbl_extend("keep", { title = name }, options))
    end)
  end)
end

function M.show_meeting_picker(names, options, cb)
  local pickers = require "telescope.pickers"
  local conf = require("telescope.config").values
  local finders = require "telescope.finders"
  local actions = require "telescope.actions"
  local action_state = require "telescope.actions.state"

  pickers.new(options, {
    prompt_title = "Meeting",
    finder = finders.new_table { results = names },
    sorter = conf.generic_sorter(options),
    attach_mappings = function(prompt_bufnr, map)
      map("i", "<C-e>", function()
        actions.close(prompt_bufnr)
        cb(action_state.get_current_line())
      end)
      actions.select_default:replace(function()
        actions.close(prompt_bufnr)
        cb(action_state.get_selected_entry().value)
      end)
      return true
    end
  }):find()
end

function M.meeting_names(notes, field, regex)
  local unique_names = {}
  for _, note in ipairs(notes) do
    local name = string.match(note[field], regex)
    if name then
      unique_names[name] = true
    end
  end
  return M.set_to_list(unique_names)
end

function M.set_to_list(set)
  local elements = {}
  for e, _ in pairs(set) do
    table.insert(elements, e)
  end
  return elements
end

If others like this idea, I can try to package it in a plug-in.

Picker for Past Meetings

Another common task I need is the ability to find my notes from the prior meeting. I created a binding in neovim <leader>-n p that will open a Telescope note pickers (with preview) for only the meetings with the same name. I.e. "Staff Meeting" in the example above. This lets me quickly review my old notes.

          function()
            local line = vim.api.nvim_buf_get_lines(0, 0, 1, false)
            if #line == 1 then
              local meeting = line[1]:match "^# %d%d%d%d%-%d%d%-%d%d: (.+)"
              if meeting then
                local filter = 'title: "' .. meeting
                local bufname = vim.api.nvim_buf_get_name(0)
                require("zk.commands").get("ZkNotes")({
                  excludeHrefs = { bufname },
                  sort = { "modified" },
                  match = filter,
                })
              end
            end
          end,

Zsh and zk autocompletion

Finally, I created a zk alias called zk meet that allows me to create a new meeting note from the command line. To sweeten the deal, I also wrote a zsh autocompletion function, so if I type zk meet <TAB> a list of all my meeting names is presented.

function _zk {
  local state line
  _arguments "1: :(init index new list graph edit tag meet)" "2:Person:->names"
  case $state in
    names)
      case $line[1] in
        meet)
          a=(${(f)"$(zk --no-prompt list -q -f '{{title}}' -t meeting | sed 's/....-..-..: \(.*\)/\1/' | sort -u)"})
          compadd -Q -a a
          ;;
        esac
        ;;
    esac
}
compdef _zk zk

[mickael-menu]

Thanks for sharing, this is awesome! I might link to it in the documentation.