Kinda working, see ext.

So it mostly works if you only use one formatting no a line, however as
soon as you use multiple, the escape characters change the positions of
the corresponding text which messes up the final rendering. I need to do
something significantly smarter for tracking character positions.

.tsk/archive/tsk-14.tsk

···
 parse internal links from body
 
+This is some !test bold text!.
+here's some =highlighted text=
+
+and finally some *italics!*
+
+here's [a link](https://ngp.computer).

src/main.rs

···
 mod errors;
 mod fzf;
 mod stack;
+mod task;
 mod util;
 mod workspace;
-mod task;
 use clap_complete::{generate, Shell};
 use errors::Result;
-use std::io;
+use std::io::{self, Write};
 use std::path::PathBuf;
 use std::process::exit;
 use std::{env::current_dir, io::Read};
···
         }
         println!("---");
     }
-    println!("{task}");
+    if let Some(styled_task) = task::parse(&task.to_string()) {
+        writeln!(io::stdout(), "{}", styled_task.content)?;
+    } else {
+        println!("{task}");
+    }
     Ok(())
 }

src/task.rs

···
 #![allow(dead_code)]
+
+use std::str::FromStr;
 use url::Url;
 
-use crate::{errors::Error, workspace::Id};
+use crate::workspace::Id;
 use colored::Colorize;
 
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
-enum ParserOpcode {
+enum ParserState {
     // Started by ` =`, terminated by `=
     Highlight(usize),
     // Started by ` [`, terminated by `](`
     Linktext(usize),
     // Started by `](`, terminated by `) `, must immedately follow a Linktext
     Link(usize),
-    // Used to signal to the parser that the Linktext parsed properly and we should parse the
-    // subsequent ( character as a
-    LinkJoin,
     // Started by ` [[`, terminated by `]] `
     InternalLink(usize),
     // Started by ` *`, terminated by `* `
···
     Underline(usize),
     // Started by ` -`, terminated by `- `
     Strikethrough(usize),
+
+    // TODO: implement these.
     // Started by `_ `, terminated by `_`
     UnorderedList(usize, u8),
     // Started by `^\w+1.`, terminated by `\n`
···
     Blockquote(usize),
 }
 
-pub(crate) struct ParsedTask {
-    content: String,
-    outgoing_internal_links: Vec<Id>,
-    links: Vec<Url>,
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub(crate) enum ParsedLink {
+    Internal(Id),
+    External(Url),
 }
 
-#[derive(Default)]
-struct ParseState {
-    highlight: Option<usize>,
-    link: Option<usize>,
-    internal: Option<usize>,
-    italics: Option<usize>,
-    bold: Option<usize>,
-    underline: Option<usize>,
-    strikethrough: Option<usize>,
-    block: bool,
-    inline: Option<usize>,
-    quote: Option<(usize, u8)>,
+pub(crate) struct ParsedTask {
+    pub(crate) content: String,
+    pub(crate) links: Vec<ParsedLink>,
 }
 
 pub(crate) fn parse(s: &str) -> Option<ParsedTask> {
-    let mut state = ParseState::default();
-    let mut out = s.to_string();
+    let mut state: Vec<ParserState> = Vec::new();
+    let mut out = String::with_capacity(s.len());
     let mut stream = s.char_indices().peekable();
-    let outgoing_internal_links = Vec::new();
-    let links = Vec::new();
+    let mut links = Vec::new();
     let mut last = '\0';
+    use ParserState::*;
     loop {
+        let state_last = state.last().cloned();
         match stream.next() {
             // there will always be an op code in the stack
             Some((pos, c)) => {
-                match (last, c, &state) {
-                    (
-                        ' ',
-                        '=',
-                        ParseState {
-                            highlight: Some(hl),
-                            ..
-                        },
-                    )
-                    | (
-                        '=',
-                        ' ',
-                        ParseState {
-                            highlight: Some(hl),
-                            ..
-                        },
-                    )
-                    | (
-                        '=',
-                        '\n',
-                        ParseState {
-                            highlight: Some(hl),
-                            ..
-                        },
-                    ) => {
+                if c == '\n' || c == '\r' {
+                    state.clear();
+                }
+                match (last, c, state_last) {
+                    ('=', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Highlight(hl))) => {
+                        state.pop();
+                        out.replace_range(
+                            hl..pos,
+                            &out.get(hl + 1..pos - 1)?.reversed().to_string(),
+                        );
+                    }
+                    (' ' | '\r' | '\n', '=', _) => {
+                        state.push(Highlight(pos));
+                    }
+                    ('[', '[', _) => {
+                        state.push(InternalLink(pos));
+                    }
+                    (']', ']', Some(InternalLink(il))) => {
+                        state.pop();
+                        let contents = out.get(il + 1..pos - 1)?;
+                        if let Ok(id) = Id::from_str(&contents) {
+                            let linktext = format!(
+                                "{}{}",
+                                contents.purple(),
+                                super_num(links.len() + 1).purple()
+                            );
+                            out.replace_range(il..pos, &linktext);
+                            links.push(ParsedLink::Internal(id));
+                        } else {
+                            panic!("Internal link is not a valid id: {contents}");
+                        }
+                    }
+                    (' ' | '\r' | '\n', '[', _) => {
+                        state.push(Linktext(pos));
+                    }
+                    (']', '(', Some(Linktext(_))) => {
+                        state.push(Link(pos));
+                    }
+                    (')', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Link(_))) => {
+                        let linkpos = if let Link(lp) = state.pop().unwrap() {
+                            lp
+                        } else {
+                            // remove the linktext state, it is always present.
+                            state.pop();
+                            continue;
+                        };
+                        let linktextpos = if let Linktext(lt) = state.pop().unwrap() {
+                            lt
+                        } else {
+                            continue;
+                        };
+                        let linktext = format!(
+                            "{}{}",
+                            out.get(linktextpos + 1..linkpos - 1)?.blue(),
+                            super_num(links.len() + 1).purple()
+                        );
+                        let link = out.get(linkpos + 1..pos - 1)?;
+                        if let Ok(url) = Url::parse(link) {
+                            links.push(ParsedLink::External(url));
+                            out.replace_range(linktextpos..pos - 1, &linktext);
+                        }
+                    }
+                    (' ' | '\r' | '\n', '*', _) => {
+                        state.push(Italics(pos));
+                    }
+                    ('*', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Italics(il))) => {
+                        state.pop();
+                        out.replace_range(il..pos, &out.get(il + 1..pos - 1)?.italic().to_string());
+                    }
+                    (' ' | '\r' | '\n', '!', _) => {
+                        state.push(Bold(pos));
+                    }
+                    ('!', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Bold(il))) => {
+                        state.pop();
+                        out.replace_range(il..pos, &out.get(il + 1..pos - 1)?.bold().to_string());
+                    }
+                    (' ' | '\r' | '\n', '_', _) => {
+                        state.push(Underline(pos));
+                    }
+                    ('_', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Underline(il))) => {
+                        state.pop();
                         out.replace_range(
-                            *hl..pos,
-                            &out.get(*hl + 1..pos - 1)?.reversed().to_string(),
+                            il..pos,
+                            &out.get(il + 1..pos - 1)?.underline().to_string(),
                         );
                     }
-                    (
-                        ' ',
-                        '=',
-                        ParseState {
-                            highlight: None, ..
-                        },
-                    ) => {
-                        state.highlight = Some(pos);
+                    (' ' | '\r' | '\n', '~', _) => {
+                        state.push(Strikethrough(pos));
                     }
-
+                    ('~', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Strikethrough(il))) => {
+                        state.pop();
+                        out.replace_range(
+                            il..pos,
+                            &out.get(il + 1..pos - 1)?.strikethrough().to_string(),
+                        );
+                    }
                     _ => (),
                 }
                 last = c;
···
     }
     Some(ParsedTask {
         content: out,
-        outgoing_internal_links,
         links,
     })
 }
 
+/// Converts a unsigned integer into a superscripted string
+fn super_num(num: usize) -> String {
+    let num_str = num.to_string();
+    let mut out = String::with_capacity(num_str.len());
+    for char in num_str.chars() {
+        out.push(match char {
+            '0' => '⁰',
+            '1' => '¹',
+            '2' => '²',
+            '3' => '³',
+            '4' => '⁴',
+            '5' => '⁵',
+            '6' => '⁶',
+            '7' => '⁷',
+            '8' => '⁸',
+            '9' => '⁹',
+            _ => unreachable!(),
+        });
+    }
+    out
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
···
 
     #[test]
     fn test_highlight_bad() {
-        let input = "hello =world";
+        let input = "hello =world\n";
         let output = parse(input).expect("parse to work");
-        assert_eq!("hello =world", output.content);
+        assert_eq!(input, output.content);
     }
 
     #[test]
     fn test_link() {
-        let input = "hello [world](https://ngp.computer)";
+        let input = "hello [world](https://ngp.computer)\n";
         let output = parse(input).expect("parse to work");
         assert_eq!(
-            &[Url::parse("https://ngp.computer").unwrap()],
+            &[ParsedLink::External(
+                Url::parse("https://ngp.computer").unwrap()
+            )],
             output.links.as_slice()
         );
-        assert_eq!("hello \u{1b}[4;94mworld\u{1b}[0m", output.content);
+        assert_eq!(
+            "hello \u{1b}[34mworld\u{1b}[0m\u{1b}[35m¹\u{1b}[0m)\n",
+            output.content
+        );
     }
 
-    #[ignore = "Known styling bug"]
     #[test]
     fn test_link_no_terminal_link() {
-        let input = "hello [world](https://ngp.computer";
+        let input = "hello [world](https://ngp.computer\n";
         let output = parse(input).expect("parse to work");
         assert!(output.links.len() == 0);
         assert_eq!(input, output.content);
     }
     #[test]
     fn test_link_bad_no_start_link() {
-        let input = "hello [world]https://ngp.computer)";
+        let input = "hello [world]https://ngp.computer)\n";
         let output = parse(input).expect("parse to work");
         assert!(output.links.len() == 0);
         assert_eq!(input, output.content);
     }
     #[test]
     fn test_link_bad_no_link() {
-        let input = "hello [world]";
+        let input = "hello [world]\n";
         let output = parse(input).expect("parse to work");
         assert!(output.links.len() == 0);
         assert_eq!(input, output.content);
+    }
+
+    #[test]
+    fn test_internal_link_good() {
+        let input = "hello [[tsk-123]]\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!(&[ParsedLink::Internal(Id(123))], output.links.as_slice());
+        assert_eq!(
+            "hello [\u{1b}[35mtsk-123\u{1b}[0m\u{1b}[35m¹\u{1b}[0m]\n",
+            output.content
+        );
+    }
+
+    #[test]
+    fn test_internal_link_bad() {
+        let input = "hello [[tsk-123";
+        let output = parse(input).expect("parse to work");
+        assert!(output.links.len() == 0);
+        assert_eq!(input, output.content);
+    }
+
+    #[test]
+    fn test_italics() {
+        let input = "hello *world*\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!("hello \u{1b}[3mworld\u{1b}[0m\n", output.content);
+    }
+
+    #[test]
+    fn test_italics_bad() {
+        let input = "hello *world";
+        let output = parse(input).expect("parse to work");
+        assert_eq!(input, output.content);
+    }
+
+    #[test]
+    fn test_bold() {
+        let input = "hello !world!\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!("hello \u{1b}[1mworld\u{1b}[0m\n", output.content);
+    }
+
+    #[test]
+    fn test_bold_bad() {
+        let input = "hello !world\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!(input, output.content);
+    }
+
+    #[test]
+    fn test_underline() {
+        let input = "hello _world_\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!("hello \u{1b}[4mworld\u{1b}[0m\n", output.content);
+    }
+
+    #[test]
+    fn test_underline_bad() {
+        let input = "hello _world\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!(input, output.content);
+    }
+
+    #[test]
+    fn test_strikethrough() {
+        let input = "hello ~world~\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!("hello \u{1b}[9mworld\u{1b}[0m\n", output.content);
+    }
+
+    #[test]
+    fn test_strikethrough_bad() {
+        let input = "hello ~world\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!(input, output.content);
+    }
+
+    #[test]
+    fn test_multiple_styles() {
+        let input = "hello *world* ~world~ !world!\n";
+        let output = parse(input).expect("parse to work");
+        assert_eq!(
+            "hello \u{1b}[3mworld\u{1b}[0m \u{1b}[9mworld\u{1b}[0m \u{1b}[1mworld\u{1b}[0m\n",
+            output.content
+        );
     }
 }