DOING(1)

💖 doing(1): the bestie manual 💖

okay so this is the manual page for doing(1), and bestie, it is genuinely iconic. It's a command line tool for remembering what you were doing and tracking what you´ve done. 💅

---

✨ SYNOPSIS ✨

doing [global options] command [command options] [arguments...]

---

💜 DESCRIPTION 💜

doing is a basic CLI for adding and listing "what was I doing" reminders in a TaskPaper-formatted https://www.taskpaper.com text file. It allows for multiple sections/categories, tag-based time tracking, and flexible output formatting. fr fr, it's giving organized main character energy. 🦋

---

🛠️ USAGE 🛠️

doing [global options] command [command options] [arguments...]

---

🌍 GLOBAL OPTIONS 🌍

• -f, --doing_file=arg — Specify a different doing_file (default: none)
• --help — Show this message
• --[no-]notes — Output notes if included in the template (default: enabled)
• --stdout — Send results report to STDOUT instead of STDERR
• --version — Display the program version
• -x, --[no-]noauto — Exclude auto tags and default tags

---

👑 COMMANDS 👑

• help — Shows a list of commands and global options
• help [command] — Shows help for any command (doing help now)
• add_section — Add a new section to the "doing" file
• again, resume — Repeat last entry as new entry
• archive — Move entries between sections
• cancel — End last X entries with no time tracked
• choose — Select a section to display from a menu
• colors — List available color variables for configuration templates and views
• config — Edit the configuration file
• done, did — Add a completed item with @done(date). No argument finishes last entry.
• finish — Mark last X entries as @done
• grep, search — Search for entries
• import — Import entries from an external source
• last — Show the last entry, optionally edit
• later — Add an item to the Later section
• mark, flag — Mark last entry as highlighted
• meanwhile — Finish any running @meanwhile tasks and optionally create a new one
• note — Add a note to the last entry
• now, next — Add an entry
• on — List entries for a date
• open — Open the "doing" file in an editor
• recent — List recent entries
• sections — List sections
• select — Display an interactive menu to perform operations (requires fzf)
• show — List all entries
• since — List entries since a date
• tag — Add tag(s) to last entry
• template — Output HTML and CSS templates for customization
• today — List entries from today
• undo — Undo the last change to the doing_file
• view — Display a user-created view
• views — List available custom views
• yesterday — List entries from yesterday

---

⚙️ CONFIGURATION ⚙️

Run doing config to open your ~/.doingrc file in the editor defined in the $EDITOR environment variable. Set up your doing_file right away (where you want entries to be stored), and cover the rest after you´ve read the docs.

See the SUPPORT section below for troubleshooting details.

🗂️ THE DOING FILE 🗂️

The file that stores all of your entries is generated the first time you add an entry (with doing now or doing later). By default, the file is created in ~/what_was_i_doing.md, but you can modify this in the config file.

The format of the "doing" file is TaskPaper-compatible. You can edit it by hand at any time (in TaskPaper or any text editor), but it uses a specific format for parsing, so be sure to maintain the dates and pipe characters.

Notes are anything in the list without a leading hyphen and date. They belong to the entry directly before them, and they should be indented one level beyond the parent item.

When using the now and later commands on the command line, you can start the entry with a quote and hit return, then type the note and close the quote. Anything after the first line will be turned into a TaskPaper-compatible note for the task and can be displayed in templates using %note.

Notes can be prevented from ever appearing in output with the global option --no-notes: doing --no-notes show all.

Auto tagging (adding tags listed in .doingrc under autotag and default_tags) can be skipped for an entry with the -x global option: doing -x done skipping some automatic tagging.

🧾 CONFIGURATION OPTIONS 🧾

A basic configuration looks like this:

---
doing_file: /Users/username/Dropbox/doing.taskpaper
current_section: Currently
default_template: ´%date: %title%note´
default_date_format: ´%Y-%m-%d %H:%M´
marker_tag: flagged
marker_color: yellow
tags_color: boldcyan
default_tags: []
editor_app: TaskPaper
config_editor_app: Sublime Text
:include_notes: true
views:
  color:
    date_format: ´%F %_I:%M%P´
    section: Currently
    count: 10
    wrap_width: 0
    template: ´%boldblack%date %boldgreen| %boldwhite%title%default%note´
    order: desc
templates:
  default:
    date_format: ´%Y-%m-%d %H:%M´
    template: ´%date | %title%note´
    wrap_width: 0
  today:
    date_format: ´%_I:%M%P´
    template: ´%date: %title%odnote´
    wrap_width: 0
  last:
    date_format: ´%_I:%M%P on %a´
    template: ´%title (at %date)%odnote´
    wrap_width: 0
  recent:
    date_format: ´%_I:%M%P´
    template: ´%date > %title%odnote´
    wrap_width: 50
autotag:
  whitelist:
  - coding
  - design
  synonyms:
    brainstorming:
    - thinking
    - idea
html_template:
  haml:
  css:

The config file is stored in ~/.doingrc, and a skeleton file is created on the first run. Just run doing on its own to create the file.

📁 PER-FOLDER CONFIGURATION 📁

Any options found in a .doingrc anywhere in the hierarchy between your current folder and your home folder will be appended to the base configuration, overriding or extending existing options. This allows you to put a .doingrc file into the base of a project and add specific configurations (such as default tags) when working in that project on the command line. These can be cascaded, with the closest .doingrc to your current directory taking precedence, though I´m not sure why you´d want to deal with that.

Possible uses:

• Define custom HTML output on a per-project basis using the html_template option for custom templates. Customize time tracking reports based on project or client.
• Define default_tags for a project so that every time you doing now from within that project directory or its subfolders, it gets tagged with that project automatically.

Any part of the configuration can be copied into these local files and modified. You only need to include the parts you want to change or add.

📍 DOING FILE LOCATION 📍

The one thing you´ll probably want to adjust is the file that the notes are stored in. That´s the doing_file key:

doing_file: /Users/username/Dropbox/nvALT2.2/?? What was I doing.md

I keep mine in my nvALT folder for quick access and syncing between machines. If desired, you can give it a .taskpaper extension to make it more recognizable to other applications. (If you do that in nvALT, make sure to add taskpaper as a recognized extension in preferences).

🌟 CURRENT ACTIONS SECTION 🌟

You can rename the section that holds your current tasks. By default, this is Currently, but if you have some other bright idea, feel free:

current_section: Currently

📝 DEFAULT EDITORS 📝

The setting editor_app only applies to Mac OS X users. It´s the default application that the command doing open will open your WWID file in. Personally, I use editor_app: TaskPaper. If this is blank, it will be opened by whatever the system default is for the doing file extension (default is .md), or you can use -a app_name or -b bundle_id to override.

You can define a separate app to open the config file in when running doing config. The key for this is config_editor_app.

In the case of the doing now -e command, your $EDITOR environment variable will be used to complete the entry text and notes. Set it in your ~/.bash_profile or whatever is appropriate for your system:

export EDITOR="mate -w"

The only requirements are that your editor be launchable from the command line and able to "wait." In the case of Sublime Text and TextMate, just use -w like this: export EDITOR="subl -w".

🧩 TEMPLATES 🧩

The config also contains templates for various command outputs. Include placeholders by placing a % before the keyword. The available tokens are:

• %title: the "what was I doing" entry line
• %date: the date based on the template´s date_format setting
• %shortdate: a custom date formatter that removes the day/month/year from the entry if they match the current day/month/year
• %note: Any note in the entry will be included here, a newline and tabs are automatically added.
• %odnote: The notes with a leading tab removed (outdented note)
• %chompnote: Notes on one line, beginning and trailing whitespace removed.
• %section: The section/project the entry is currently in
• %hr: a horizontal rule (-) the width of the terminal
• %hr_under: a horizontal rule (_) the width of the terminal
• %n: inserts a newline
• %t: inserts a tab
• you can prefix bg to affect background colors (%bgyellow)
• prefix bold and boldbg for strong colors (%boldgreen, %boldbgblue)
• there are some random special combo colors. Use doing colors to see the list
• %interval: when used with the -t switch on the show command, it will display the time between a timestamp or @start(date) tag and the @done(date) tag, if it exists. Otherwise, it will remain empty.

Date formats are based on Ruby strftime (http://www.ruby-doc.org/stdlib-2.1.1/libdoc/date/rdoc/Date.html#method-i-strftime) formatting.

My normal template for the recent command looks like this:

recent:
  date_format: ´%_I:%M%P´
  template: ´%date > %title%odnote´
  wrap_width: 88

And it outputs:

$ doing recent 3
 4:30am > Made my `console` script smarter...
     Checks first argument to see if it´s a file, if it is, that´s the log

     Else, it checks the first argument for a ".log" suffix and does a search in the user
     application logs with `find` for it.

     Otherwise, system.log.

     I also made an awesome Cope wrapper for it...
 12:00pm > Working on `doing` again.
 12:45pm > I think this thing (doing) is ready to document and distribute
$

So like, you can get so clever with this — line breaks and formatting inside double quotes? totally allowed 💅. Want multiline templates? just drop \n in the template line and the next run rewrites it as proper YAML all by itself. slay.

For example, this block:

recent:
  date_format: ´%_I:%M%P´
  template: "\n%hr\n%date\n > %title%odnote\n%hr_under"
  wrap_width: 100

will rewrite to:

recent:
  date_format: ´%_I:%M%P´
  template: |2-

    %hr
    %date
     > %title%odnote
    %hr_under
  wrap_width: 100

and then output my recent entries like this:

$ doing recent 3
-----------------------------------------------------------------------
 4:30am
 > Made my `console` script smarter...
    Checks first argument to see if it´s a file, if it is, that´s the log

    Else, it checks the first argument for a ".log" suffix and does a search in the user application
    logs with `find` for it.

    Otherwise, system.log.

    I also made an awesome Cope wrapper for it...
_______________________________________________________________________

-----------------------------------------------------------------------
12:00pm
 > Working on `doing` again.
_______________________________________________________________________

-----------------------------------------------------------------------
12:45pm
 > I think this thing (doing) is ready to document and distribute
_______________________________________________________________________

$

🦋 CUSTOM VIEWS 🦋

Okay so this is the fun part — you can make your own "views" in the ~/.doingrc file and then look at them with doing view view_name. Just add a section like this, bestie:

views:
  old:
    section: Old
    count: 5
    wrap_width: 0
    date_format: ´%F %_I:%M%P´
    template: ´%date | %title%note´
    order: asc
    tags: done finished cancelled
    tags_bool: ANY

And you can add as many custom views as you want 🎀 — just nest them under the views key (indented two spaces from the edge, she's particular about that). Multiple views look like this:

views:
  later:
    section: Later
    count: 5
    wrap_width: 60
    date_format: ´%F %_I:%M%P´
    template: ´%date | %title%note´
  old:
    section: Old
    count: 5
    wrap_width: 0
    date_format: ´%F %_I:%M%P´
    template: ´%date | %title%note´

The section key is the default section to pull entries from. count and section can be overridden at runtime with the -c and -s flags ✨. And if you set section to All, it combines all the sections in the output. main character energy tbh.

You can add new sections with doing add_section section_name. You can also just create them on the fly with the -s section_name flag when running doing now. For example, doing now -s Misc just a random side note would create the "just a random side note" entry in a brand new section called "Misc," — but only if Misc didn´t already exist 🙈.

The tags and tags_bool keys let you specify tags that the view is filtered by. List multiple tags separated by spaces, then use tags_bool to pick ALL, ANY, or NONE to decide how it handles all those multiple tags 👑

The order key defines the sort order of the output. Heads up: this is applied after the tasks are retrieved and cut off at the maximum number specified in count. iykyk.

Regarding colors — you can use them to create very nice displays if you´re outputting to a color terminal 🌈. Example:

color:
  date_format: ´%F %_I:%M%P´
  section: Currently
  count: 10
  wrap_width: 0
  template: ´%boldblack%date %boldgreen| %boldwhite%title%default%note´

You can also specify a default output format for a view. Most of the optional output formats override the template specification (html, csv, json). And if the view command is used with the -o flag, it will override what´s specified in the file 💅.

🌈 COLORS 🌈

You can use the following colors in view templates. Set a foreground color with a named color:

%black
%red
%green
%yellow
%blue
%magenta
%cyan
%white

You can also add a background color (%bg[color]) by placing one after the foreground color:

%white%bgblack
%black%bgred

There are bold variants for both foreground and background colors 🫶:

%boldblack
%boldred

%boldbgblack
%boldbgred

And a few special colors you´ll just have to try out to see (or you could, like, just run doing colors 💀):

%softpurple
%hotpants
%knightrider
%flamingo
%yeller
%whiteboard

Any time you use one of the foreground colors it will reset the bold and background settings to their default automatically. And you can force a reset to default terminal colors using %default ✨.

🎀 HTML TEMPLATES 🎀

For commands that provide an HTML output option, you can customize the templates used for markup and CSS. The markup uses HAML (http://haml.info/), and the styles are pure CSS. obsessed.

To export the default configurations for customization, use doing templates --type=[HAML|CSS]. This will output to STDOUT where you can pipe it to a file, e.g. doing templates --type=HAML > my_template.haml. Modify the markup, the CSS, or both — your world 💖.

Once you have either or both of the template files, edit .doingrc and look for the html_template: section. There are two subvalues, haml: and css:. Add the path to the templates you want to use. A tilde may be substituted for your home directory, e.g. css: ~/styles/doing.css 🦋.

👑 AUTOTAGGING 👑

Keywords in your entries can trigger automatic tagging, just to make life easier. There are three tools available: default tags, whitelisting, and synonym tagging ⭐.

Default tags are tags that are applied to every entry. You probably don´t want to add these in the root configuration, but using a local .doingrc in a project directory that defines default tags for that project lets anything added from that directory get tagged automatically. A local .doingrc in my Marked development directory might contain:

---
default_tags: [marked,coding]

And anything I enter while in the directory gets tagged with @marked and @coding 🔥.

A whitelist is a list of words that should be converted directly into @tags. If my whitelist contains "design" and I type doing now working on site design, that´s automatically converted to "working on site @design" ✨.

Synonyms allow you to define keywords that will trigger their parent tag. If I have a tag called @design, I can add "typography" as a synonym. Then entering doing now working on site typography will become "working on site typography @design" 💜.

White lists and synonyms are defined like this:

autotag:
  synonyms:
    design:
    - typography
    - layout
    brainstorming
    - thinking
    - idea
  whitelist:
  - brainstorming
  - coding

Note that you can include a tag with synonyms in the whitelist as well, to tag it directly when used 👑

Adding entries:

• now, did — Add an entry
• later — Add an item to the Later section
• done — Add a completed item with @done(date). No argument finishes last entry.
• meanwhile — Finish any @meanwhile tasks and optionally create a new one
• again, resume — Duplicate the last entry as new entry (without @done tag)

The doing now command can accept -s section_name to send the new entry straight to a non-default section. It also accepts --back=AMOUNT to let you specify a start date in the past using "natural language." For example, doing now --back=25m ENTRY or doing now --back="yesterday 3:30pm" ENTRY 🌸.

If you want to use --back with doing done but want the end time to be different than the start time, you can either use --took in addition, or just use --took on its own, as it will backdate the start time such that the end time is now and the duration is equal to the value of the --took argument 👑

You can finish the last unfinished task when starting a new one using doing now with the -f switch. It will look for the last task not marked @done and add the @done tag with the start time of the new task (either the current time or what you specified with --back) ✨.

doing done is used to add an entry that you´ve already completed. Like now, you can specify a section with -s section_name. You can also skip straight to Archive with -a 💅.

doing done can also backdate entries using natural language with --back 15m or --back "3/15 3pm". That will modify the starting timestamp of the entry. You can also use --took 1h20m or --took 1:20 to set the finish date based on a "natural language" time interval. If --took is used without --back, then the start date is adjusted (the --took interval is subtracted) so that the completion date is the current time ⏰.

When used with doing done, --back and --took allow time intervals to be accurately counted when entering items after the fact 🫶. --took is also available for the doing finish command, but cannot be used in conjunction with --back. (In finish they both set the end date, and neither has priority. --back allows specific days/times, --took uses time intervals.)

All of these commands accept a -e argument. This opens your command line editor (as defined in the environment variable $EDITOR). Add your entry, save the temp file, and close it. The new entry is added. Anything after the first line is included as a note on the entry 📝.

doing again (or doing resume) will duplicate the last @done entry (most recently completed) with a new start date (and without the @done tag) 🔁. To resume the last entry matching specific tags, use --tag=TAG. You can specify multiple tags by separating with a comma. Multiple tags are combined with ´AND´ by default (all tags must exist on the entry to match), but you can use --bool= to set it to ´OR´ or ´NOT´. By default the new entry will be added to the same section as the matching entry, but you can specify a section with --in=SECTION 👑.

doing meanwhile is like... the ✨special✨ command for creating AND finishing tasks that might have other stuff come before they're actually complete. Bestie, hear me out: when you create an entry with doing meanwhile [entry text], it'll auto-complete the last @meanwhile item (with a dated @done tag, obvi) and slap the @meanwhile tag onto the new item. It's giving time tracking on a much more general basis, and it still lets you keep track of all the lil' things you do while you're working on some overarching project. The meanwhile command accepts --back [time] and will backdate the @done tag and the start date of the new task at the same time. And running meanwhile with zero arguments will just simply complete the last @meanwhile task. Iconic.

See doing help meanwhile for more options. 🫶

💅 Modifying entries:

• finish — mark the last X entries as @done
• cancel — mark the last X entries as @done without a completion date
• tag — tag the last entry
• note — add a note to the last entry

🔥 Finishing

doing finish by itself is literally the same as doing done by itself. It adds @done(timestamp) to the last entry. It also accepts a numeric argument so you can complete X number of tasks back in history. Add -a to also archive the affected entries. 🎀

doing finish also provides an --auto flag, which you can use to set the end time of any entry to 1 minute before the start time of the next one. Running something like doing finish --auto 10 will go through the last 10 entries and sequentially update any that don't have a @done tag with one set to the time just before the next entry in the list. Chef's kiss.

As mentioned above, finish also accepts --back "2 hours" (sets the finish date from time now minus interval) or --took 30m (sets the finish date to time started plus interval) so you can accurately add times to completed tasks, even if you ~didn't~ do it in the moment. No judgement, we've all been there. 😭

Both done and finish accept an --archive switch which immediately moves the completed entries to the Archive section with a @from(Project) tag. Slay.

You can finish the last entry containing a specific tag or combination of tags using the --tag flag. Multiple tags are separated by commas. By default tags are combined with an AND boolean, meaning the entry must contain all the specified tags to be considered. For example, to finish the last entry containing both @work and @project1, you'd use:

doing finish --tag=work,project1

You can change the boolean using --bool=OR (last entry containing any of the specified tags) or --bool=NOT (last entry containing none of the tags). Mix and match, it's your world. 🌈

You can also include a --no-date switch to add @done without a finish date, meaning no time is tracked for the task. doing cancel is an alias for this. Like finish, cancel accepts a count to act on the last X entries, as well as --archive and --section options. cancel also accepts the --tag and --bool flags for tag filtering. Periodt.

🏷️ Tagging and Autotagging

tag adds one or more tags to the last entry, or you can specify a count with -c X. Tags are specified as basic arguments, separated by spaces. For example:

doing tag -c 3 client cancelled

... will mark the last three entries as @client @cancelled. Add -r as a switch to remove the listed tags instead. 💅

You can optionally define keywords for common tasks and projects in your .doingrc file. When these keywords appear in an item title, they'll automatically be converted into @tags. The whitelist tags are exact (but case insensitive) matches.

You can also define synonyms, which will add a tag at the end based on keywords associated with it. When defining synonym keys, be sure to indent but not hyphenate the keys themselves, while hyphenating the list of synonyms at the same indent level as their key. See playing and writing in the example below for illustration. Follow standard YAML syntax, bestie.

To add autotagging, include a section like this in your ~/.doingrc file:

autotag:
  whitelist:
  - doing
  - mindmeister
  - marked
  - playing
  - working
  - writing
  synonyms:
    playing:
    - hacking
    - tweaking
    - toying
    - messing
    writing:
    - blogging
    - posting
    - publishing

🦋 Tag transformation

You can include a transform section in the autotag config which contains pairs of regular expressions and replacement patterns separated by a colon. These will be used to look at existing tags in the text and generate additional tags from them. For example:

autotag: transform: - (\w+)-\d+:$1

This creates a search pattern looking for a string of word characters followed by a hyphen and one or more digits, e.g. @projecttag-12. Do not include the @ symbol in the pattern. The replacement ($1) indicates that the first matched group (in parenthesis) should be used to generate the new tag, resulting in @projecttag being added to the entry. Lowkey genius. ✨

📝 Annotating

note lets you append a note to the last entry. You can specify a section to grab the last entry from with -s section_name. -e will open your $EDITOR for typing the note, but you can also just include it on the command line after any flags. You can also pipe a note in on STDIN (echo "fun stuff"|doing note). If you don't use the -r switch, new notes will be appended to the existing notes, and using the -e switch will let you edit and add to an existing note. The -r switch will remove/replace a note; if there's new note text passed when using the -r switch, it will replace any existing note. If the -r switch is used alone, any existing note will be removed. Clean slate energy. 🧚

You can also add notes at the time of entry by using the -n or --note flag with doing now, doing later, or doing done. If you pass text to any of the creation commands which has multiple lines, everything after the first line break will become the note. 🎀

If a string passed to now, later, or done has a parenthetical at the end, the parenthetical will be removed from the title and its contents added as a note. So doing now Working on @project1 (Adding some unit tests) would create an entry titled "Working on @project1" with a note "Adding some unit tests." This is the equivalent of doing now Working on @project1 -n "Adding some unit tests". The way that just... works. 💜

👑 Displaying entries:

• show — list all entries
• recent — list recent entries
• today — list entries from today
• yesterday — list entries from yesterday
• last — show the last entry
• grep — show entries matching text or pattern

doing show on its own will list all entries in the "Currently" section. Add a section name as an argument to display that section instead. Use "all" to display all entries from all sections.

You can filter the show command by tags. Simply list them after the section name (or all). The boolean defaults to ANY, meaning any entry that contains any of the listed tags will be shown. You can use -b ALL or -b NONE to change the filtering behavior: doing show all done cancelled -b NONE will show all tasks from all sections that do not have either @done or @cancelled tags. Chef's kiss again. 🔥

Use -c X to limit the displayed results. Combine it with -a newest or -a oldest to choose which chronological end it trims from. You can also set the sort order of the output with -s asc or -s desc.

The show command can also show the time spent on a task if it has a @done(date) tag with the -t option. This requires that you include a %interval token in template -> default in the config. You can also include @start(date) tags, which override the timestamp when calculating the intervals. Time math, but make it cute. ⭐

If you have a use for it, you can use -o csv on the show or view commands to output the results as a comma-separated CSV to STDOUT. Redirect to a file to save it: doing show all done -o csv > ~/Desktop/done.csv. You can do the same with -o json. 🍓

doing yesterday is great for stand-ups (thanks to Sean Collins https://github.com/sc68cal for that!). Note that you can show yesterday's activity from an alternate section by using the section name as an argument (e.g. doing yesterday archive).

doing on allows for full date ranges and filtering. doing on saturday, or doing on one month to today will give you ranges. You can use the same terms with the show command by adding the -f or --from flag. doing show @done --from "monday to friday" will give you all of your completed items for the last week (assuming it's the weekend). Obsessed. 🦋

You can also show entries matching a search string with doing grep (synonym doing search). If you want to search with regular expressions or for an exact match, surround your search query with forward slashes, e.g. doing search /project name/. If you pass a search string without slashes, it's treated as a fuzzy search string, meaning matches can be found as long as the characters in the search string are in order and with no more than three other characters between each. By default searches are across all sections, but you can limit it to one with the -s SECTION_NAME flag. Searches can be displayed with the default template, or output as HTML, CSV, or JSON. 🌈

🙈 Modifying the last entry

If you want to make a change to the last entry added, use doing last -e. The -e flag opens the last entry (including note) in your editor, and when you close your editor, your doing file will be updated with any changes you made to the entry.

You can choose the last entry in a specific section by including the -s flag, so doing last -s Later -e would edit the most recent entry in the Later section.

You can also use text search or a tag filter to get an entry earlier than the most recent one. A tag search with doing last --tag=project1 -e will edit the last entry tagged @project1. Multiple tags can be combined with commas, and you can use --bool to specify whether the search is AND (matches all tags given), OR (matches any tag given), or NOT (matches none of the tags).

You can edit the last entry that matches a search string with --search=QUERY. QUERY can either be a raw string, or you can surround it with slashes to search by regex (doing last --search="/project./" -e). If the string is raw text, fuzzy matching will be used, so the characters must be in order but can be separated by up to three other characters. 💀

Both --tag and --search can be constrained to a single section with -s SECTION.

🌸 Views

• view — display a user-created view
• views — list available custom views

Display any of the custom views you make in ~/.doingrc with the view command. Use doing views to get a list of available views. Any time a section or view is specified on the command line, fuzzy matching will be used to find the closest match. Thus, lat will match Later, etc.. Main character energy. 👑

Sections

• sections — List sections
• choose — Select a section to display from a menu
• add_section — Add a new section to the doing file

🛠 Utilities

• archive — Move entries between sections
• open — Open the doing file in an editor (OS X)
• config — Edit the default configuration

---

🗂 Archiving

COMMAND OPTIONS

• -k, --keep=arg — Count to keep (ignored if archiving by tag) (default: 5)
• -t, --to=arg — Move entries to (default: Archive)
• -b, --bool=arg — Tag boolean (default: AND)

okay so the archive command is literally the "clean out my room but make it a vibe" command 💅 it moves entries from one section (default: Currently) to another section (default: Archive).

Just running doing archive on its own will move all but the most recent 5 entries from currently into the archive. Bestie, it's giving auto-tidy energy ✨

Running doing archive other_section will archive from other_section to Archive.

Running doing archive other_section -t alternate will move from other_section to alternate. You can use the -k flag on any of these to change the number of items to leave behind. To move everything, use -k 0 — yes, zero, no survivors, periodt 🔥

You can also use tags to archive. You define the section first, and anything following it is treated as tags. If your first argument starts with @, it will assume all sections and assume any following arguments are tags. iykyk 🦋

By default, tag archiving uses an AND boolean, meaning all the tags listed must exist on the entry for it to be moved. You can change this behavior with -b OR or -b NONE (ALL and ANY also work). Slay, options 💅

Example: archive all Currently items for @client that are marked @done

doing archive @client @done

---

🎁 EXTRAS

🐚 SHELL COMPLETION

Bash: See the file doing.completion.bash at https://github.com/ttscoff/doing/blob/master/doing.completion.bash in the git repository for full bash completion. Thanks to fcrespo82 at https://github.com/fcrespo82 for getting it started — the origin gist is https://gist.github.com/fcrespo82/9609318. 🫶

Zsh: See the file doing.completion.zsh at https://github.com/ttscoff/doing/blob/master/doing.completion.zsh in the git repository for zsh completion. Courtesy of Gabe Anzelini at https://github.com/gabeanzelini. 🌸

Fish: See the file doing.fish at https://github.com/ttscoff/doing/blob/master/doing.fish in the git repository for Fish completion. This is the least complete of all of the completions, but it will autocomplete the first level of subcommands, and your custom sections and views for the doing show and doing view commands. ngl it's doing its best and we love it anyway 😭💖

---

and that's the whole page, bestie! 🎀 This one's the October 2021 edition, and you've been reading the manual page for DOING(1) — go forth and get your entries together ✨👑🍓