obsidian-tasks-group / obsidian-tasks Goto Github PK
View Code? Open in Web Editor NEWTask management for the Obsidian knowledge base.
Home Page: https://publish.obsidian.md/tasks/
License: MIT License
Task management for the Obsidian knowledge base.
Home Page: https://publish.obsidian.md/tasks/
License: MIT License
I'd like to be have a tasks search query filter on:
heading includes Tasks
To be able to grab all checklists under specific headings
### Tasks
or
heading does not include Goals
to ignore checklists under specific headings
### Goals
Is it for keywords that are mentioned in a task? For instance, if there is the task - [ ] Task A is part of Project A #task
, the filter does not work if I try this: description includes Project A
.
I don’t want to add the due date emoji by hand and then manually type the due date.
Instead, there should be a command that opens a pop up. In the pop up I can select a date. When I confirm the pop up, the “due date emoji” and due date are appended to the task in the file.
It can be very simple 4 drop downs for year/month/day in first iteration.
Sometimes one may want to better show tasks related to a project. For instance, Task A and Task B are also listed in the file Project A. Is it possible to better show this? For instance, one may add tags to Task A and Task B as follows:
Content of Project A:
- [ ] Task A #task #ProjectA
- [ ] Task B #task #ProjectA
Then one can filter #ProjectA
to show these tasks.
Obsidian 12.0.0 ships with an extended metadata cache that indexes lists. I can get the tasks from the lists metadata cache instead of reading all the files myself.
A potential optimization. It is not guaranteed to be useful 🤔
The cache currently notifies its subscribers on every cache update (e.g. file modification).
It could make sense to only notify the subscribers when the cache has actually changed.
Given that a task is included via a ```tasks block
When the preceding header (section header) equals the file name
Then the link after the task is shown as e.g. (Obsidian > Obsidian)
But instead, when they are equal, only show the file name (but still link to the section), e.g. `(Obsidian)`
The longer version provides no additional information to the user while it takes up screen space.
In the current implementation, block identifiers at the end of a line (^id123
) are removed when the task status is toggled. Instead, the block identifier should remain with the task.
Given that I use a global filter (e.g. #task)
And that I am at the end of the line of a task
When I hit enter to create the next line
That new line should be a checklist item that starts with the global filter
This way, I don’t have to write #task
over and over when I want to note multiple tasks.
The cache doesn't need to reload a file immediately on every modification.
Instead, there should be a minimum time to wait between refreshes.
A modification after a long pause should be refreshed immediately, but then there should be a break.
Queue up all relevant files and process them when the time has come.
Make sure that new modifications are pushed to a new queue while the cache processes the old queue.
Within Note A, there are the following tasks:
- TODO take out the trash 📅 2021-05-09
- TODO Test Markdown tasks
Within the daily note template, the following queries are used:
However, within today's daily note, the tasks are rendered as follows:
take out the trash 📅 2021-05-09
should not appear in "Due in the next two weeks".
An optional pane independent from files and queries could list tasks. Should include filter options from Query. It must be possible to toggle status there.
The todo.txt format is quite widely used and supported by other tools. How things are specified is clearly defined. Is there a reason not to support that format? It feels like it would extend the applicability of this - the widespread use of that format plus the power of your querying tools would make a good combination.
At the moment, task queries have fixed dates, but something like due before date(today)
would be so useful to identify overdue tasks on my "Dashboard" page. I know you have a long list of todos :-) but I hope you find room for this one.
And I so agree with your distinction between checklists and tasks to manage. So glad that you want to develop a plugin that knows the difference. ❤️
Cache initializing can take some time, depending on the size of the vault. Instead of showing nothing until the cache is initialized, show Tasks loading ...
.
In the latest version, children tasks are shown as undone if they are not checked, although the corresponding parent task is marked as done. This is a little different from ordinary Obsidian tasks in Preview mode. Is it possible to make it more consistent with ordinary obsidian tasks?
This makes it possible to "skip" tasks and so on. These tasks are not open anymore. Obsidian's metadata cache behavior is the same.
If tasks are shown as indented, it would be easier to connect them to the context and the corresponding projects.
If the tasks are indented, maybe they can be indented the same as they are in the source file, whether the parent has the tag #task
or not and whether the parent is a task or a list item or not. For instance, the following Task A and Task B can be shown as they are.
Tasks of Project A:
- [ ] Task level 1
- [ ] Task level 2
- [ ] Task A #task
- Item level 2
- [ ] Task B #task
Or maybe this can be an option, and the user can decide whether to show tasks as indented or not in the configuration page.
Is it possible to support tasks created with ordinary Markdown format, i.e. - [ ] TODO test creating a task
? Also, when rendering tasks like this in preview mode, there can be only one checkbox rather than two.
Hello!
This is similar to the issue where any task handled by tasks lacked the data-task
property.
There is a data-line
property with the li row number in both the li
and the nested input
that disappears whenever I add the #task property to the todo item.
In the latest version of Tasks, it seems that the filter path
works both for path/folder/directory and file/file name. Is it possible to distinguish them as Obsidian does? Specifically, the filter path
denote a folder/directory while file
denotes a file name.
Given that I use a global filter #task
When I nest tasks under a general checklist item
Then the markdown preview of the file is messed up
But instead it should render as expected
The rendering in the markdown preview adds the text of the first task in the sub-list to the checklist item (replacing the checklist item's text). All other checklist items/tasks "move up by one" content-wise.
This doesn't work:
- [ ] A list of tasks:
- [ ] #task This is my first task
- [ ] #task This is my second task
This works:
- [ ] #task A list of tasks:
- [ ] #task This is my first task
- [ ] #task This is my second task
Currently, text like ✅ 2021-04-09
would be appended to the end of the task when it is marked as DONE. Is it possible to customize this? For instance, if ✅ [[2021-04-09]]
is appended, then one can check in the Graph View what tasks have been completed on a specific date; if ✅ 202104141210
is appended, then one can know the specific time when a task is completed.
When I add a tasks query block,
It should be possible to sort the tasks.
The keywords ascending
and descending
should be optional.
It should default to ascending
.
The following sorting should be available (can be extended later):
sort by due date [ascending|descending]
sort by done date [ascending|descending]
For now, only one sort is sufficient. Maybe later it should be possible to “sort by priority first, due date second” or something like this.
If no sort is given or the sorting parameter is equal for two tasks, sorting should default/fall back to:
Thank you for this great plug-in! I'm just starting to test it out and it would be great to have a Command for a new tasks to allow for a keyboard shortcut. Ideally with the ability to set a default style (e.g., - [ ]
or -[ ] #tasks
and have some automatically included info, such as creation date. E.g., The command "Tasks: Create new task with creation date" would create a template on the following line:
- [ ] 📆 2021-04-25
Related to #5
Thanks for considering this!
When I click on a checkbox of a task
I should get immediate feedback that I clicked it.
Instead, it can take some time until the change is a) done in the file where the task is and b) also shown in my current view. I could see a transclusion that only gets updated once the cache reparsed the entire file that contains the task.
The checkbox should have a state that shows that I successfully clicked it, but it should not change to the desired result before the change was actually made. It must be a temporary state, where the checkbox is ideally visibly disables.
When creating a tasks
code block, it should be possible to add grouping to the query.
If tasks shall be grouped, split the cached tasks into groups after filtering, but before sorting.
Sort each group individually.
Put a h4
of the group before the grouped items (e.g. #### 2021-09-12
or #### DONE
)
Grouping should be possible by:
Example:
group by due date
Question: Is this really necessary? Right now you can have “groups” by having multiple ```tasks blocks below each other.
When I have a task, e.g. - TODO
, in the editor, the keyword should be replaced with a tasks checkbox.
Should it be clickable? 🤔
The Transclusion
's onunload
method is always called immediately.
Therefore, onunload
is disabled for the moment.
It should be made working properly, so that the number of targets that the cache renders during an update doesn't grow without ever shrinking.
Currently, tasks are identified by list items that contain a nodeChild
of type text that starts with a task keyword (e.g. TODO
).
The task, when toggled, identifies its original source in the file based on string similarity, which is not very accurate. Especially considering that the markdown to HTML renderer potentially changed the text.
Normal checkboxes are handled by offset in the file and index in the list (when a section is rendered by the markdown renderer)(Based on a discussion on discord). Does a plugin have access to this offset? Maybe in the context? That would solve it, as we could use section indices in addition to the page indices we have from the cache. We could then start at the offset and identify the task by its task index. Maybe it’s even more efficient/easier to use the existing list index? 🤔
When filtering a tasks block, add a new filter that filters by tag.
Example:
```tasks
has tag #tag1
```
Alternatively, maybe extend it to general inclusion of a string which would also allow filtering for tags?
```tasks
includes text #tag1
```
Relates to #19
It should be possible to filter tasks based on when they are scheduled. This helps declutter the tasks list by only showing tasks that are already scheduled.
A new emoji could indicate a scheduled date, e.g. ⏳ 2021-09-12
. Then filtering could be done like:
```tasks
scheduled before 2021-12-30
```
With #1, filtering could be done like scheduled before tomorrow
.
A task should have an optional recurrence (like an optional due date).
Recurrence should be written as natural language, like in Todoist.
Examples:
Once a task is set as recurring, a new task must be created once the original task is marked as DONE (or SKIPPED or DELEGATED). A new task must be created so that the original task can be marked DONE and appear in queries where I want to see tasks that were done on a certain date, as an example.
The new task should appear right above the existing task in the same file with the same indentation.
This isn’t ideal, as this could get very long. I wasn’t able to come up with something nicer which is also plain markdown. Ideas?
At the end of the query results, show (dimmed) the number of tasks in that list.
Should also show when there are 0 tasks in this list.
A task should be able to have a priority.
The priority should be signified by an emoji (like a due date) followed by the priority as a number.
Any numbers should be fine for priorities and users can use whatever system they want.
The README should show a simple example where priorities 1
- 4
exist and 1
is the highest priority / 4
is least important.
Right now it can be tricky to select the correct calendar symbol when entering a due date.
Instead, Tasks should accept all calendar icons as due date:
Otherwise it would be confusing if someone installed an older version of this plugin in an older version of obsidian.
The checkbox of a task should have a prominent style in order to signify a task.
If possible, use existing css variables from the background/foreground to be in line with the current theme.
When I embed a ```tasks block, I want to be able to filter dates also by relative statements.
In addition to, for example, due before 2021-09-12
, relative dates could help with a page where I always have certain tasks. That page could look something like the following, as an example:
# Tasks
## Overdue
```tasks
due before today
not done
```
## Due today
```tasks
due on today
not done
```
## Due this week
```tasks
due after today
due before in 8 days
not done
```
On the Insider Build of Obsidian the value of a tasks checkbox is available in the data-task
attribute of the list item.
- [x] Task 1
- [>] Deferred task
<li data-line="0" data-task="x" class="task-list-item is-checked">
<li data-line="1" data-task=">" class="task-list-item is-checked">
but with the Tasks plugin active this attribute no longer populates.
Noticed this when the custom CSS that relies on this behavior did not work: https://github.com/deathau/obsidian-snippets#checkboxes
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google ❤️ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.