"Micro" time tracker

A minimalistic time-tracker that reads and writes to Markdown files.

Made in Godot. Source https://github.com/aleksandrbazhin/MicroTimeTracker

Embedded task tracking

Track all the tasks side by side with the source code. For many jam or solo projects tracking the tasks in the Markdown files without leaving your IDE is enough.

Time tracking is not essential to this, but that way you at least get a reminder what you are working on.

The "Micro" time tracker parses tasks in your markdown files, recognizing lists with the checkboxes. Then it displays them in the UI and appends time spent on each task to those files.

Example

Here is a markdown file

rendered by github and opened by the Microtracker

Markdown subset syntax

The following is recognized in a Markdown task file. Tasks are from github format.

"# "       - task block, any level header in markdown.  
             All the tasks should be in one of the task blocks. 
"\n- [ ] " - uncompleted task 
"\n- [x] " - completed task 
(added automatically)
" **(int:int:int)**" - time spend on the task at the end of the task string

Everything else you can use to format the files as you want. Such time tracking is not enforcing anything. You obviously can also edit the time anytime you want. Exact regular expression used are at the bottom of the page.

Sync

It's supposed to be synced by git along with the main project, so every member should better use different file with tasks, just to avoid merge conflicts. If you trust your cloud provider, like Google Disk or Dropbox, you can sync with it.

When the file that was loaded into the Microtimetracler differs from the file on disk, warning will be shown since the program no longer can write task statuses and time without damaging the file :

 

Pros:

• You don't depend on cloud service providers.
• You don't leave IDE to check tasks. (Don't get distracted by those browser and web interfaces.)
• You can synchronize task statuses with Git along with your commits.
• You don't lose your task change history if you use Git.

Cons:

• There is no way to intelligently sync file, that is being currently used to track the time. You are at your own here. The program will track the hash of the last used markdown file and if current file differs, the program instead of saving to the file, will display the warning and prompt you to reload the file. Desyncs can happen when file was changed:

  • by you in some external text editor
  • after git pull
  • after git check out to another branch or commit

• Individual contributions are neither measured, nor time spent on one task by different members is added. You have to add it yourself while resolving merge conflicts. Best solution will be to have individual files or track time outside the git repo being used.

Tips:

1. You can edit all markdown files with VSCode for example, there are some nice extensions for the github format previews (those checklists).

   • Markdown Preview Enhanced
   • GitHub Markdown Preview
   • Markdown Preview Github Styling

2. You can use folders with files task lists as canban boards. When all task in the file are done, move it to another folder, something like that, I guess.

3. To prevent desync use personal markdown files with task lists, which aren't updated by other users.

Final notice

It's not MICRO,  because Godot is a game engine, which is embedded int a tiny app. Comparing with some Electron-based apps, however...

It's a prototype. I had something like that in mind for some time to decouple from cloud providers. If this project catches interest I may rewrite it in something more suitable instead of a game engine, like Qt. Or you can do it yourself.