Optional feature to reorder checked lines to the top or bottom of the checkmark list

[StephenArg]

Describe feature

So a feature I've seen elsewhere on other note taking applications is for checked lines in a list of checkboxes to reorder themselves so the unchecked and checked lines are always grouped together. It can be annoying for the lines to quickly "disappear" when checked, so perhaps there can be some cleanup function to it where it reorders the list after a few minutes or hours. That way when you return to the list is orderly and what still needs to be done is grouped together.

Additional Information

Since it doesn't work like this now, it would be nice to have it added as an optional feature.

[Nriver]

Years ago, I built a function using ETAPI with python, called move_yesterday_unfinished_todo_to_today :) and set up a cron job to run it every day at 00:15.

https://github.com/Nriver/trilium-py#move-yesterdays-unfinished-todo-to-today

[StephenArg]

@Nriver Thanks! I'll try this out!

It's probably better to have it be a native option though, but that's up to the main dev team I guess.

[StephenArg]

@Nriver So I just tried out that command. It didn't actually do what I was expecting.

What I want to do is something like this. If you have a list in a note like this:

• What
• The
• Heck
• Bro

After the script runs it should be:

• What
• Heck
• The
• Bro

[Nriver]

Well, the idea is quite similar. I made a new function to do that. https://github.com/Nriver/trilium-py#sort-todo

Sort today's todos, put finished todos to the bottom and keep relative order

ea.sort_todo()

Sort for some day

ea.sort_todo(date="2026-05-26")

Sort and push newly finished items to the bottom

ea.sort_todo(append_new_done=True)

[StephenArg]

Well, the idea is quite similar. I made a new function to do that. https://github.com/Nriver/trilium-py#sort-todo

Sort today's todos, put finished todos to the bottom and keep relative order

ea.sort_todo()

Sort for some day

ea.sort_todo(date="2026-05-26")

Sort and push newly finished items to the bottom

ea.sort_todo(append_new_done=True)

I just tried this out.

It doesn't work. I read more about the implementation and I think this is assuming the note I'm trying to reorder is a journal note assigned to a specific date (today by default).

The type of feature I'm describing would account for any changed notes that have checkboxes. At a certain time a day, it would go through these notes, find the groups of checkboxes, then reorder the groups with the unchecked either at the top or bottom of the grouping, together.

This would encompass all notes that have checkboxes in them that were changed since the last run.

[eliandoran]

@StephenArg , as an exercise, it would be interesting to try the new AI chat, ask it to create a script which would do this for you.

[Nriver]

I made a change to the function, now it supports noteId.

ea.sort_todo(noteId="fn1DVZBsiQBG")

You can find all notes with unchecked checkbox with the search query.

note.type = text AND note.rawContent *=* '<input type="checkbox" disabled="disabled">'

Backup before you do anything : )

[StephenArg]

@eliandoran I don't have keys for those providers. Are you saying I should just make a plugin though?

Edit: Just checked. I don't see an option for plugins :/

[StephenArg]

I made a change to the function, now it supports noteId.

ea.sort_todo(noteId="fn1DVZBsiQBG")

You can find all notes with unchecked checkbox with the regex.

note.type = text AND note.rawContent *=* '<input type="checkbox" disabled="disabled">'

Backup before you do anything : )

@Nriver So this basically goes through every single note? That's a bit much. Would probably be more efficient if the app did this itself. Easier for it to track which notes are changed.

[eliandoran]

@StephenArg , there is not yet a concept for plugins in Trilium. But yes, I'm saying this can be implemented as a frontend or backend script (see https://docs.triliumnotes.org/user-guide/scripts).

[Nriver]

Well, that's the best ETAPI can do. If you want more precise controls, you'll need to write a plugin then. I think you can do something with Trilium 's runOnNoteContentChange event.

[StephenArg]

@eliandoran @Nriver Ok, this solution worked well!

Make a note (code note).
On the bottom bar, change "Plain text" to JS Backend.

Add these two tags (bottom right where it says "[some number] attributes"):
#run=hourly #runAtHour=3

The number for runAtHour corresponds to the hour you want to run it on 24 hour time.

Then add this code to the note and you're good.

/*
Checkbox-group sorter for Trilium JS backend notes.

What it does:
- Runs at #runAtHour=<hour> when this note has #run=hourly.
- Finds text notes modified in the last WINDOW_HOURS hours.
- Parses each note's HTML.
- For each contiguous run of checkbox <li> items inside a <ul> or <ol>:
  - keeps checked items together at the top,
  - moves unchecked items together to the bottom,
  - preserves the relative order within the checked and unchecked groups.

Setup labels on this JS backend code note:
  #run=hourly
  #runAtHour=3
*/

const WINDOW_HOURS = 24;
const INCLUDE_ARCHIVED_NOTES = false;

// Set to true for a log-only test run. Set back to false when satisfied.
const DRY_RUN = false;

// Optional subtree limiter.
// Leave blank to scan all recently modified text notes.
// Example: const LIMIT_TO_ANCESTOR_TITLE = "Projects";
const LIMIT_TO_ANCESTOR_TITLE = "";

const LOOKBACK_SECONDS = WINDOW_HOURS * 60 * 60;

function escapeSearchString(value) {
    return String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'");
}

function buildSearchQuery() {
    const clauses = [
        "note.type = text",
        `note.dateModified >= NOW-${LOOKBACK_SECONDS}`
    ];

    if (LIMIT_TO_ANCESTOR_TITLE.trim()) {
        clauses.push(`note.ancestors.title = '${escapeSearchString(LIMIT_TO_ANCESTOR_TITLE.trim())}'`);
    }

    return clauses.join(" AND ");
}

function tagName(node) {
    return (node?.tagName || node?.rawTagName || "").toLowerCase();
}

function isLi(node) {
    return tagName(node) === "li";
}

function getOwnCheckbox(li) {
    if (!li?.querySelectorAll) {
        return null;
    }

    const inputs = li.querySelectorAll('input[type="checkbox"], input[type=checkbox]');

    for (const input of inputs) {
        // Avoid treating a parent <li> as checked just because a nested sub-list has a checkbox.
        const closestLi = input.closest ? input.closest("li") : null;

        if (closestLi === li) {
            return input;
        }
    }

    return null;
}

function isCheckboxLi(li) {
    return isLi(li) && !!getOwnCheckbox(li);
}

function isCheckedLi(li) {
    const checkbox = getOwnCheckbox(li);

    if (!checkbox?.getAttribute) {
        return false;
    }

    // node-html-parser returns undefined when an attribute is not set.
    const checkedAttr = checkbox.getAttribute("checked");
    return checkedAttr !== undefined && checkedAttr !== null;
}

function sameNodeOrder(a, b) {
    return a.length === b.length && a.every((node, idx) => node === b[idx]);
}

function sortCheckboxRunsInList(list) {
    const children = Array.from(list.children || []);
    const reorderedChildren = [];
    let changed = false;

    for (let i = 0; i < children.length;) {
        const child = children[i];

        if (!isCheckboxLi(child)) {
            reorderedChildren.push(child);
            i++;
            continue;
        }

        const run = [];

        while (i < children.length && isCheckboxLi(children[i])) {
            run.push(children[i]);
            i++;
        }

        const checked = run.filter(isCheckedLi);
        const unchecked = run.filter(li => !isCheckedLi(li));
        const sortedRun = checked.concat(unchecked);

        if (
            run.length > 1 &&
            checked.length > 0 &&
            unchecked.length > 0 &&
            !sameNodeOrder(run, sortedRun)
        ) {
            changed = true;
        }

        reorderedChildren.push(...sortedRun);
    }

    if (changed) {
        // This rewrites the direct children of the list. The <li> nodes themselves,
        // including nested lists and formatting, are preserved.
        list.set_content(reorderedChildren);
    }

    return changed;
}

function sortCheckboxGroupsInHtml(html) {
    const root = api.htmlParser.parse(html, {
        comment: true,
        blockTextElements: {
            script: true,
            noscript: true,
            style: true,
            pre: true
        }
    });

    const lists = [
        ...root.querySelectorAll("ul"),
        ...root.querySelectorAll("ol")
    ];

    let changed = false;

    for (const list of lists) {
        if (sortCheckboxRunsInList(list)) {
            changed = true;
        }
    }

    return {
        changed,
        html: changed ? root.toString() : html
    };
}

function processNote(note) {
    if (!note || note.isDeleted || note.isBeingDeleted) {
        return false;
    }

    if (typeof note.hasStringContent === "function" && !note.hasStringContent()) {
        return false;
    }

    if (typeof note.isContentAvailable === "function" && !note.isContentAvailable()) {
        return false;
    }

    const originalContent = note.getContent();

    if (typeof originalContent !== "string") {
        return false;
    }

    // Cheap pre-check to avoid parsing notes that definitely do not contain checkboxes.
    if (!/type=["']?checkbox["']?/i.test(originalContent)) {
        return false;
    }

    const result = sortCheckboxGroupsInHtml(originalContent);

    if (!result.changed || result.html === originalContent) {
        return false;
    }

    if (DRY_RUN) {
        api.log(`[DRY RUN] Would sort checkbox groups in: ${note.title} (${note.noteId})`);
        return true;
    }

    note.setContent(result.html);
    api.log(`Sorted checkbox groups in: ${note.title} (${note.noteId})`);
    return true;
}

const query = buildSearchQuery();

api.log(`Checkbox sorter scanning with query: ${query}`);

const notes = api.searchForNotes(query, {
    includeArchivedNotes: INCLUDE_ARCHIVED_NOTES,
    ignoreHoistedNote: true
});

let changedCount = 0;

api.transactional(() => {
    for (const note of notes) {
        try {
            if (processNote(note)) {
                changedCount++;
            }
        } catch (e) {
            api.log(`Checkbox sorter failed for ${note?.title || "unknown note"} (${note?.noteId || "no id"}): ${e.stack || e.message || e}`);
        }
    }
});

api.log(`Checkbox sorter finished. Notes scanned: ${notes.length}. Notes changed: ${changedCount}.`);

[eliandoran]

@StephenArg , glad you could set it up by yourself.

As a future improvement, you might consider keeping this script as a one-off execution to process old notes, but create a frontend script which hooks to the CKEditor and automatically reorders the TODOs when they are done. This would be a bit harder to implement but it would yield a better user experience.

[StephenArg]

Yea there were some events to trigger when the notes content changes. I could probably use that instead. For my personal use I wanted this to happen once a day as a generic cleanup since sometimes I want the line to stay in place for at least a few minutes to an hour after I've been checking and unchecking boxes.