Fix parsing, allow multiline push

.tsk/archive/tsk-31.tsk

···
+DO THE THING
+
+
+remember to do part1
+
+and part2
+
+and part3

.tsk/index

···
-tsk-30	Add flag to only print IDs in list command	1735007126
+tsk-30	Add flag to only print IDs in list command	1763257109
 tsk-28	Add tool to clean up old tasks not in index	1735006519
 tsk-10	foreign workspaces	1732594198
 tsk-21	Add command to setup git stuff	1732594198
-tsk-8	IMAP4-based sync	1732594198
+tsk-8	IMAP4-based sync	1767469318
 tsk-17	Add reopen command	1732594198
-tsk-16	Add ability to search archived tasks with find command	1732594198
+tsk-16	Add ability to search archived tasks with find command	1767466011
 tsk-15	Add link identification to tasks	1732594198
 tsk-9	fix timestamp storage and parsing	1732594198
 tsk-7	allow for creating tasks that don't go to top of stack	1732594198

.tsk/next

···
-31
+32

flake.nix

···
     utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = { self, nixpkgs, utils, naersk }:
-    utils.lib.eachDefaultSystem (system:
+  outputs =
+    {
+      self,
+      nixpkgs,
+      utils,
+      naersk,
+    }:
+    utils.lib.eachDefaultSystem (
+      system:
       let
         pkgs = import nixpkgs { inherit system; };
         naersk-lib = pkgs.callPackage naersk { };
       in
       {
         defaultPackage = naersk-lib.buildPackage ./.;
-        devShell = with pkgs; mkShell {
-          buildInputs = [ libiconv cargo rustc rustfmt rust-analyzer rustPackages.clippy plan9port pandoc ];
-          RUST_SRC_PATH = rustPlatform.rustLibSrc;
-        };
+        devShell =
+          with pkgs;
+          mkShell {
+            buildInputs = [
+              libiconv
+              cargo
+              rustc
+              rustfmt
+              rust-analyzer
+              rustPackages.clippy
+              plan9port
+              pandoc
+              codeberg-cli
+            ];
+            RUST_SRC_PATH = rustPlatform.rustLibSrc;
+          };
       }
     );
 }

readme

···
 A quick overview of the format:
 
 - \!Bolded\! text is surrounded by exclamation marks (!)
-- \*Italicized\* text is surrouneded by single asterists (*)
+- \*Italicized\* text is surrounded by single asterisks (*)
 - \_Underlined\_ text is surrounded by underscores (_)
-- \~Strikenthrough\~ text is surrounded by tildes (~)
+- \~Strikethrough\~ text is surrounded by tildes (~)
+- \=Highlighted\= text is surrounded by equals signs (=)
+- \`Inline code\` is surrounded by backticks (`)
 
 Links like in Markdown, along with the wiki-style links documented above.
+Raw links can also be written as \<https://example.com\>.
 
 Misc
 ----

src/main.rs

···
     } else {
         "".to_string()
     };
-    let mut body = body.unwrap_or_default();
+    // If no body was explicitly provided and the title contains newlines,
+    // treat the first line as the title and the rest as the body (like git commit -m)
+    let mut body = if body.is_none() {
+        if let Some((first_line, rest)) = title.split_once('\n') {
+            let extracted_body = rest.to_string();
+            title = first_line.to_string();
+            extracted_body
+        } else {
+            String::new()
+        }
+    } else {
+        // Body was explicitly provided, so strip any newlines from title
+        title = title.replace(['\n', '\r'], " ");
+        body.unwrap_or_default()
+    };
     if body == "-" {
         // add newline so you can type directly in the shell
         //eprintln!("");
···
             body = content.1.to_string();
         }
     }
+    // Ensure title never contains newlines (invariant for index file format)
+    title = title.replace(['\n', '\r'], " ");
     let task = workspace.new_task(title, body)?;
     workspace.handle_metadata(&task, None)?;
     Ok(task)
···
     let pre_links = task::parse(&task.to_string()).map(|pt| pt.intenal_links());
     let new_content = open_editor(format!("{}\n\n{}", task.title.trim(), task.body.trim()))?;
     if let Some((title, body)) = new_content.split_once("\n") {
-        task.title = title.to_string();
+        // Ensure title never contains newlines (invariant for index file format)
+        task.title = title.replace(['\n', '\r'], " ");
         task.body = body.to_string();
         workspace.handle_metadata(&task, pre_links)?;
         task.save()?;

src/task.rs

···
 use crate::workspace::Id;
 use colored::Colorize;
 
+/// Returns true if the character is a word boundary (whitespace or punctuation)
+fn is_boundary(c: char) -> bool {
+    c.is_whitespace() || c.is_ascii_punctuation()
+}
+
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 enum ParserState {
     // Started by ` =`, terminated by `=
···
                             panic!("Internal link is not a valid id: {contents}");
                         }
                     }
-                    (' ' | '\r' | '\n', '[', _) => {
+                    (last, '[', _) if is_boundary(last) => {
                         state.push(Linktext(end, char_pos));
                     }
                     (']', '(', Some(Linktext(_, _))) => {
                         state.push(Link(end, char_pos));
                     }
-                    (')', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Link(_, _))) => {
+                    (')', c, Some(Link(_, _))) if is_boundary(c) => {
                         // TODO: this needs to be updated to use `s` instead of `out` for position
                         // parsing
                         let linkpos = if let Link(lp, _) = state.pop().unwrap() {
···
                             out.replace_range(linktextpos..end, &linktext);
                         }
                     }
-                    ('>', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(RawLink(hl, s_pos)))
-                        if s_pos != char_pos - 1 =>
+                    ('>', c, Some(RawLink(hl, s_pos)))
+                        if is_boundary(c) && s_pos != char_pos - 1 =>
                     {
                         state.pop();
                         let link = s.get(s_pos + 1..char_pos - 1)?;
···
                             out.replace_range(hl..end, &linktext);
                         }
                     }
-                    (' ' | '\r' | '\n', '<', _) => {
+                    (last, '<', _) if is_boundary(last) => {
                         state.push(RawLink(end, char_pos));
                     }
-                    ('=', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Highlight(hl, s_pos)))
-                        if s_pos != char_pos - 1 =>
+                    ('=', c, Some(Highlight(hl, s_pos)))
+                        if is_boundary(c) && s_pos != char_pos - 1 =>
                     {
                         state.pop();
                         out.replace_range(
···
                             &s.get(s_pos + 1..char_pos - 1)?.reversed().to_string(),
                         );
                     }
-                    (' ' | '\r' | '\n', '=', _) => {
+                    (last, '=', _) if is_boundary(last) => {
                         state.push(Highlight(end, char_pos));
                     }
-                    (' ' | '\r' | '\n', '*', _) => {
+                    (last, '*', _) if is_boundary(last) => {
                         state.push(Italics(end, char_pos));
                     }
-                    ('*', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Italics(il, s_pos)))
-                        if s_pos != char_pos - 1 =>
+                    ('*', c, Some(Italics(il, s_pos)))
+                        if is_boundary(c) && s_pos != char_pos - 1 =>
                     {
                         state.pop();
                         out.replace_range(
···
                             &s.get(s_pos + 1..char_pos - 1)?.italic().to_string(),
                         );
                     }
-                    (' ' | '\r' | '\n', '!', _) => {
+                    (last, '!', _) if is_boundary(last) => {
                         state.push(Bold(end, char_pos));
                     }
-                    ('!', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Bold(il, s_pos)))
-                        if s_pos != char_pos - 1 =>
-                    {
+                    ('!', c, Some(Bold(il, s_pos))) if is_boundary(c) && s_pos != char_pos - 1 => {
                         state.pop();
                         out.replace_range(
                             il..end,
                             &s.get(s_pos + 1..char_pos - 1)?.bold().to_string(),
                         );
                     }
-                    (' ' | '\r' | '\n', '_', _) => {
+                    (last, '_', _) if is_boundary(last) => {
                         state.push(Underline(end, char_pos));
                     }
-                    ('_', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Underline(il, s_pos)))
-                        if s_pos != char_pos - 1 =>
+                    ('_', c, Some(Underline(il, s_pos)))
+                        if is_boundary(c) && s_pos != char_pos - 1 =>
                     {
                         state.pop();
                         out.replace_range(
···
                             &s.get(s_pos + 1..char_pos - 1)?.underline().to_string(),
                         );
                     }
-                    (' ' | '\r' | '\n', '~', _) => {
+                    (last, '~', _) if is_boundary(last) => {
                         state.push(Strikethrough(end, char_pos));
                     }
-                    ('~', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Strikethrough(il, s_pos)))
-                        if s_pos != char_pos - 1 =>
+                    ('~', c, Some(Strikethrough(il, s_pos)))
+                        if is_boundary(c) && s_pos != char_pos - 1 =>
                     {
                         state.pop();
                         out.replace_range(
···
                             &s.get(s_pos + 1..char_pos - 1)?.strikethrough().to_string(),
                         );
                     }
-                    ('`', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(InlineBlock(hl, s_pos)))
-                        if s_pos != char_pos - 1 =>
+                    ('`', c, Some(InlineBlock(hl, s_pos)))
+                        if is_boundary(c) && s_pos != char_pos - 1 =>
                     {
                         out.replace_range(
                             hl..end,
                             &s.get(s_pos + 1..char_pos - 1)?.green().to_string(),
                         );
                     }
-                    (' ' | '\n' | '\r' | '.' | '!' | '?', '`', _) => {
+                    (last, '`', _) if is_boundary(last) => {
                         state.push(InlineBlock(end, char_pos));
                     }
                     _ => (),