Chronos Timeline (Community Plugin)

Chronos + Dataview + Tasks

Okay. That all works pretty well now. However, I’ve found another community plugin that has a very nice system that I would like integrate this sort of system into. I’ll show you my dataview + mermaid gantt workflow for some inspiration. However, TO BE CLEAR, this does NOT use mermaid or gantt anymore. This is a Chronos timeline based approach that I’m now taking

Here’s the things I need to implement with the new Chronos plugin:

  • Parse the tasks date into the format that Chronos uses ✅ 2025-02-24
  • Colors based on priority ✅ 2025-02-24
  • Use a dash in the task title to break the event up into title and description. If there’s nested bullet points under the task, then parse those into the description if possible. ✅ 2025-02-24
  • Leave an option/frontmatter to turn on these aspects at will along with other variables or behavior like with the breadcrumb vs full ✅ 2025-02-24
  • Give an option to tune the order behavior ✅ 2025-02-24
  • Use the status of tasks to also affect the color ✅ 2025-02-24
  • Add links to the related task

Extra features:

  • Points
    • For tasks which don’t have a combination of start OR created + due date, make them points ✅ 2025-02-24
    • When a created date or scheduled date is used and no other date or priority, use a point with a purple color, else give the priority ✅ 2025-02-24
    • When a started date is used and no other date or priority, use a point with a green color ✅ 2025-02-24
    • When a due date is used and no other date or priority, use a point with a red color ✅ 2025-02-24
    • For points that are created from tasks, use the green or red respectively when a start or due date is used. If no start or due date is used, then use the scheduled date or the created date (purple). If a priority is also specifically given, then use the related priority color instead and prioritize showing that color. To be explicit here, prioritize showing priority colors ✅ 2025-02-24
  • Functioning ChildLaneOption behavior
    • Groups based on the tags (use the breadcrumb and full as options again w/top-level used for major groups). This has stopped working properly it seems. ✅ 2025-02-24
  • Creating periods
    • Use period deeper than 2 depths on the tag to make a period instead of assuming the 2nd level is one. If a description is given, then then instead use a “period” and base the color of the period of the, again, the task priority and/or status. Done or cancelled could be the only time that green or red are used for instance to show those superseding statuses. ✅ 2025-02-24
    • To reiterate, let’s say that someone defines a task [ ] test_title - desc_or_no_desc \#roadmap/section/period 🛫 2025-02-27 📅 2025-05-15. This means that a period of “test_title” should be created under “section”. However, this means that it has to have a start or created date along with a due date to define the range. I would rather have this than the less intuitive way I was creating periods before ✅ 2025-02-24
    • Moreover, if I create a period at a 2nd level and the “full” option is being used for child lanes, then that period needs to be duplicated for each of those generated child sections below it ✅ 2025-02-24

Later:

  • When a frontmatter property named “marker__COLOR_NAME_HERE: date” is used, make a pointer at that date with that name and color
  • When a frontmatter property named “group_NAME_HERE: date_range” is used, make a group at that range with that name
  • When a frontmatter property named “period_COLOR_NAME_HERE: date_range” is used, make a period at that range with that name and color
  • Give default view dates that define the start and end date such as used in previous code
  • Give an option for how to display quarters as either points at the top or bottom of the timeline or as Markers
  • Be able to take the current year from start and end and auto-generate the quarters and put them in as markers
  • When roadmap/manual is given, then allow child list items below that task to act as manual items to be ingested at the bottom of the chronos timeline instantiation
  • When more than one year is given, generate more “quarters”
  • Take broken dates and put them in a custom section to help find broken tasks

TEST ZONE

quarterDivider:: “[Q#]“

Look at Obsidian Roadmaps for the established tasks

V1.0

Use TODO v0 to find items that need added or fixed

roadmapTitle:: “Roadmap” roadmapDateFormat:: “YYYY-MM-DD” roadmapDefaultLane:: “General” roadmapStart:: “2025-01-01” roadmapEnd:: “2025-12-31” roadmapLinkTasks:: false roadmapPointHasColor:: true roadmapShowQuarters:: true roadmapChildLaneOption:: “breadcrumb”

“breadcrumb” (default) or “full”

//////////////////////////////////////////////////////////////////////////////////////////
// 1. CONFIGURATION PULLED FROM FRONTMATTER OR INLINE FIELDS
//////////////////////////////////////////////////////////////////////////////////////////
 
const cfg = {
    // Basic timeline settings
    title: dv.current().roadmapTitle || "Roadmap",
    defaultLane: dv.current().roadmapDefaultLane || "General",
 
    // "breadcrumb" => append nested path (except 'period') to the item label
    // "full" => skip 'period' but incorporate the rest into the group name
    childLaneOption: dv.current().roadmapChildLaneOption || "breadcrumb",
 
    // Colors & Priority
    overdueSuffix: dv.current().roadmapOverdueSuffix || " overdue",
    overdueFlag: dv.current().roadmapOverdueFlag || "red",
    priorityColors: {
        Highest: "red",
        High: "orange",
        Medium: "blue",
        Low: "cyan",
        Lowest: "gray"
    },
    doneColor: "green", // color for done tasks
    cancelledColor: "red", // color for cancelled tasks
 
    // Subtasks -> description
    captureSubtasks: true,
 
    // Single-date => `*`
    singleDateChar: "*",
 
    // Single-date color defaults
    givePointsColor: dv.current().roadmapPointHasColor !== false,
    createdOnlyColor: "purple",
    startedOnlyColor: "green",
    dueOnlyColor: "red",
 
    // Link tasks to their notes
    linkTasks: dv.current().roadmapLinkTasks || false,
 
    // Quarter Markers
    showQuarters: dv.current().roadmapShowQuarters !== false,
    quarterPlacement: "top", // or "bottom" or "none"
 
    // Date Range for Chronos defaultView
    defaultViewStart: dv.current().roadmapStart || "",
    defaultViewEnd: dv.current().roadmapEnd || "",
 
    // Ordering in Chronos
    orderBy: dv.current().orderBy || "start",
};
 
//////////////////////////////////////////////////////////////////////////////////////////
// 2. HELPER FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////
 
// Priority from emojis
const emojiPriorityMap = {
    "🔺": "Highest",
    "⏫": "High",
    "🔼": "High",
    "⏺️": "Medium",
    "🔽": "Low",
    "⏬": "Lowest"
};
 
function getPriorityFromText(text) {
    for (let e in emojiPriorityMap) {
        if (text.includes(e)) return emojiPriorityMap[e];
    }
    return "";
}
 
// Parse #roadmap markers
// e.g. #roadmap/one/period/two => lane="one", chain=["period","two"]
function parseRoadmapMarkers(txt) {
    const rx = /#roadmap(?:\/([\w-]+))?(?:\/([\w-]+))?(?:\/([\w-]+))?(?:\/([\w-]+))?/;
    let m = txt.match(rx);
    let rootLane = cfg.defaultLane;
    let rest = [];
    if (m) {
        if (m[1]) rootLane = m[1];
        for (let i = 2; i < m.length; i++) {
            if (m[i]) rest.push(m[i]);
        }
    }
    return {
        rootLane,
        rest
    };
}
 
// Function that extracts a sub-bullet list for a given task, if desired.
function gatherSubBullets(task) {
    if (!cfg.captureSubtasks || !task.subtasks) return "";
    // Let's build a bullet list of subtask lines
    // This can be refined to skip completed or do something else
    let arr = [];
    for (let s of task.subtasks) {
        // skip if done or not, your choice
        arr.push(s.text + ". ");
    }
    if (arr.length > 0) {
        return "" + arr.join(". ");
    }
    return "";
}
 
// Split "title - desc" into [title, desc]
function parseTitleDesc(str) {
    let idx = str.indexOf(" - ");
    if (idx < 0) return [str.trim(), ""];
    let t = str.slice(0, idx).trim();
    let d = str.slice(idx + 3).trim();
    return [t, d];
}
 
// Color from done/cancelled tasks
function getStatusColor(task) {
    if (task.status === "done") return `#${cfg.doneColor}`;
    if (task.status === "cancelled") return `#${cfg.cancelledColor}`;
    return "";
}
 
// Convert date object to Chronos-friendly YYYY-MM-DD
function toChronosDate(dObj) {
    return dObj.toString().split("T")[0];
}
 
/**
 * Build the final Chronos line from parameters
 * @param {string} lineChar  e.g. '-', '*', '@'
 * @param {string} dateSyntax e.g. '[2025-01-01~2025-02-01]' or '[2025-01-10]'
 * @param {string} colorPart e.g. '#red'
 * @param {string} lane e.g. '{someLane}'
 * @param {string} label e.g. 'Title | Desc'
 */
function makeChronosLine(lineChar, dateSyntax, colorPart, lane, label) {
    let segs = [];
    segs.push(`${lineChar} ${dateSyntax}`);
    if (colorPart) segs.push(colorPart);
    if (lane) segs.push(`{${lane}}`);
    segs.push(label);
    return segs.join(" ");
}
 
function collectAllFullLanes(tasks) {
  let dict = {};
  for (let t of tasks) {
    // parse
    const { rootLane, rest } = parseRoadmapMarkers(t.text);
    if (!rootLane) continue;
 
    // >>> Filter out 'period' from rest to avoid unwanted lanes like "root/period"
    let filteredRest = rest.filter(seg => seg !== "period");
 
    // build expansions from rootLane + filteredRest
    let expansions = [];
    let current = rootLane;
    expansions.push(current);
 
    for (let i = 0; i < filteredRest.length; i++) {
      current += "/" + filteredRest[i];
      expansions.push(current);
    }
 
    if (!dict[rootLane]) dict[rootLane] = new Set();
    expansions.forEach(e => dict[rootLane].add(e));
  }
 
  // convert sets to arrays
  for (let k in dict) {
    dict[k] = Array.from(dict[k]);
  }
  return dict;
}
 
//////////////////////////////////////////////////////////////////////////////////////////
// 3. MAIN CODE
//////////////////////////////////////////////////////////////////////////////////////////
 
let lines = [];
 
// 3.1. Query tasks that contain #roadmap
const tasks = dv.pages("").file.tasks
    .where(t => t.text.includes("#roadmap"));
 
// 3.1.1 Gather all sub-lanes for root => expansions
const allFullLanes = collectAllFullLanes(tasks);
 
for (let task of tasks) {
    // Potential date fields
    let created = task.created;
    let scheduled = task.scheduled;
    let start = task.start;
    let due = task.due;
 
    let cDate = created ? toChronosDate(created) : "";
    let sDate = start ? toChronosDate(start) : "";
    let dDate = due ? toChronosDate(due) : "";
    let schDate = scheduled ? toChronosDate(scheduled) : "";
 
    // Identify lane + chain
    let {
        rootLane,
        rest
    } = parseRoadmapMarkers(task.text);
 
    // Clean text for base title
    let cleaned = task.text
        .replace(/#[\w\/-]+/g, "")
        .replace(/[🚩🔺⏫⏺️🔽⏬➕🛫📅]/g, "")
        .replace(/\d{4}-\d{2}-\d{2}/g, "")
        .trim();
    let [title, desc] = parseTitleDesc(cleaned);
 
    // Subtasks
    if (cfg.captureSubtasks && task.subtasks) {
        let sb = gatherSubBullets(task);
        if (sb) desc += (desc ? "\n" + sb : sb);
    }
 
    // Linking
    if (cfg.linkTasks && task.link) {
        desc += desc ? `\n[[${task.link}]]` : `[[${task.link}]]`;
    }
 
    // Decide final lane name and title modifications based on childLaneOption
    // If rest has 'period' we might skip it from the lane or treat differently
    let isPeriodTask = false;
    let laneName = rootLane;
 
    // Check if the second element is 'period'
    // e.g. rest = ["period"] or ["period","someOther"...]
    // if rest[0] === 'period', we want a period for any range
    // and we skip 'period' from lane building
    if (rest.length > 0 && rest[0] === "period") {
        isPeriodTask = true;
        // So we skip rest[0] => 'period' from the group name
        rest.shift();
    }
 
    if (cfg.childLaneOption === "full" && rest.length > 0) {
        laneName = rootLane + "/" + rest.join("/");
    } else if (cfg.childLaneOption === "breadcrumb" && rest.length > 0) {
        // Append them to the title (except 'period' which we already shifted out)
        title += ` (${rest.join("/")})`;
    }
 
    // Priority & status color
    let prio = getPriorityFromText(task.text);
    let color = getStatusColor(task); // done/cancelled => override
    if (!color && prio && cfg.priorityColors[prio]) {
        color = `#${cfg.priorityColors[prio]}`;
    }
 
    // Overdue?
    let isOverdue = false;
    if (dDate && task.status === "pending") {
        isOverdue = new Date(dDate) < new Date();
    }
    if (isOverdue) {
        color = `#${cfg.overdueFlag}`;
        title += cfg.overdueSuffix;
    }
 
    // Determine leftSide & rightSide for a range
    let leftSide = "";
    let rightSide = "";
    // prefer start => left, else created or scheduled
    if (sDate) leftSide = sDate;
    else if (cDate) leftSide = cDate;
    else if (schDate) leftSide = schDate;
 
    if (dDate) rightSide = dDate;
 
    // Are we a range or a single date?
    let hasRange = (leftSide && rightSide && leftSide !== rightSide);
 
    let lineChar = "-";
    let dateSyntax = "";
	if (isPeriodTask && cfg.childLaneOption === "full") {
	    if (hasRange) {
	        // We have dateSyntax = `[leftSide~rightSide]`
	        // and isPeriodTask indicates #roadmap/.../period
	        dateSyntax = `[${leftSide}~${rightSide}]`;
	
	        if (isPeriodTask && cfg.childLaneOption === "full") {
			  // Instead of only building expansions from root+rest,
			  // we look up all known expansions for this root in `allFullLanes[rootLane]`.
			  // Then produce a line for each if we have a valid date range (hasRange).
			  if (hasRange) {
			    let sublanes = allFullLanes[rootLane] || [];
			    // We have a dateSyntax = `[${leftSide}~${rightSide}]`
			    let lbl = desc ? `${title} | ${desc}` : title;
			    sublanes.forEach(l => {
			      // For each sub-lane under rootLane, produce a period line
			      let line = makeChronosLine("@", `[${leftSide}~${rightSide}]`, color, l, lbl);
			      lines.push(line);
			    });
			    continue; // skip normal single-lane push
			  } 
			  else {
			    // It's a "period" marker, but only a single date => just do normal single-line approach
			    // e.g. * [someDate]
			    // or skip if you prefer
			  }
			}
	    } else {
	        // single date => point
	        let singleDate = leftSide || rightSide;
	        if (!singleDate) {
	            // no date => skip
	            continue;
	        }
	        lineChar = cfg.singleDateChar; // default '*'
	        dateSyntax = `[${singleDate}]`;
	
	        // If givePointsColor => color a single date
	        if (cfg.givePointsColor && !color) {
	            // only start => green, only due => red, only created/sched => purple
	            let usedCount = [sDate, dDate, cDate, schDate].filter(x => x).length;
	            if (usedCount === 1) {
	                // figure out which one
	                if (sDate) color = `#${cfg.startedOnlyColor}`;
	                else if (dDate) color = `#${cfg.dueOnlyColor}`;
	                else color = `#${cfg.createdOnlyColor}`; // cDate or schDate
	            }
	        }
	    }
	} else {
		// Normal single-lane approach
		let lineChar = isPeriodTask ? "@" : "-";
		
		if (hasRange) {
		  dateSyntax = `[${leftSide}~${rightSide}]`;
		
		  // If it's a period task:
		  if (isPeriodTask) {
		    // If FULL => replicate expansions for each sub-lane
		    if (cfg.childLaneOption === "full") {
		      let sublanes = allFullLanes[rootLane] || [];
		      let lbl = desc ? `${title} | ${desc}` : title;
		      sublanes.forEach(l => {
		        let line = makeChronosLine("@", dateSyntax, color, l, lbl);
		        lines.push(line);
		      });
		      continue; // skip single-lane
		    }
		    else {
		      // BREADCRUMB mode => single period line
		      lineChar = "@";
		    }
		  } else {
		    lineChar = "-";
		  }
		
		  let lbl = desc ? `${title} | ${desc}` : title;
		  let finalLine = makeChronosLine(lineChar, dateSyntax, color, laneName, lbl);
		  lines.push(finalLine);
		  continue;
		} else {
	        // single date => point
	        let singleDate = leftSide || rightSide;
	        if (!singleDate) {
	            // no date => skip
	            continue;
	        }
	        lineChar = cfg.singleDateChar; // default '*'
	        dateSyntax = `[${singleDate}]`;
	
	        // If givePointsColor => color a single date
	        if (cfg.givePointsColor && !color) {
	            // only start => green, only due => red, only created/sched => purple
	            let usedCount = [sDate, dDate, cDate, schDate].filter(x => x).length;
	            if (usedCount === 1) {
	                // figure out which one
	                if (sDate) color = `#${cfg.startedOnlyColor}`;
	                else if (dDate) color = `#${cfg.dueOnlyColor}`;
	                else color = `#${cfg.createdOnlyColor}`; // cDate or schDate
	            }
	        }
	    }
	}
 
    // Build final label
    let lbl = desc ? `${title} | ${desc}` : title;
    let finalLine = makeChronosLine(lineChar, dateSyntax, color, laneName, lbl);
 
    lines.push(finalLine);
}
 
// 3.2. Build the Chronos code block
let out = [];
out.push("```chronos");
// DefaultView
if (cfg.defaultViewStart && cfg.defaultViewEnd) {
    out.push(`> DEFAULTVIEW ${cfg.defaultViewStart}|${cfg.defaultViewEnd}`);
}
// ORDERBY
out.push(`> ORDERBY ${cfg.orderBy}`);
 
out.push(`# ${cfg.title}`);
 
// Insert Q1..Q4 if showQuarters
if (cfg.showQuarters && cfg.defaultViewStart && cfg.defaultViewEnd) {
    let sy = Number(moment(cfg.defaultViewStart).format("YYYY"));
    let ey = Number(moment(cfg.defaultViewEnd).format("YYYY"));
    if (sy === ey) {
        let q1 = moment(cfg.defaultViewStart).month(0).format("YYYY-MM-DD");
        let q2 = moment(cfg.defaultViewStart).month(2).endOf("month").format("YYYY-MM-DD");
        let q3 = moment(cfg.defaultViewStart).month(5).endOf("month").format("YYYY-MM-DD");
        let q4 = moment(cfg.defaultViewStart).month(8).endOf("month").format("YYYY-MM-DD");
        if (cfg.quarterPlacement === "top") {
            out.push(`= [${q1}] Q1`);
            out.push(`= [${q2}] Q2`);
            out.push(`= [${q3}] Q3`);
            out.push(`= [${q4}] Q4`);
        }
    }
}
 
for (let ln of lines) {
    out.push(ln);
}
 
out.push("```");
 
console.log(`${out.join("\n")}`)
 
dv.paragraph(out.join("\n"));

V0.1

/****************************************************************************************
 * "Chronos Timeline" Generator from Tasks
 *
 * This code collects tasks with certain markers, processes them according to 
 * user-defined frontmatter or inline config, and outputs a "```chronos" codeblock.
 *
 * Key Features:
 *  - Parse #roadmap tasks and optionally nest them.
 *  - Show single-date tasks as points or markers in Chronos if desired.
 *  - Show range tasks (start & due) as events or periods.
 *  - Color tasks by priority or status.
 *  - Use grouping based on root-level segments (dfir for #roadmap/dfir) 
 *    or "full" path or a "breadcrumb" approach.
 *  - Insert user-specified date range for Chronos's default view 
 *    (like > DEFAULTVIEW start|end).
 *  - Optional quarter markers if the user desires, or some other marking approach.
 *  - Insert sub-bullets under tasks (subtasks) into the item description if desired.
 *  - Break the Chronos line at the first dash (`-`) to produce `Event Title | Description`.
 ****************************************************************************************/
 
//////////////////////////////////////////////////////////////////////////////////////////
// 1. CONFIGURATION PULLED FROM FRONTMATTER OR INLINE FIELDS
//////////////////////////////////////////////////////////////////////////////////////////
 
const config = {
  // Basic timeline settings
  title: dv.current().roadmapTitle || "Timeline",
  dateFormat: dv.current().roadmapDateFormat || "YYYY-MM-DD", 
  defaultLane: dv.current().roadmapDefaultLane || "General",
  groupMode: dv.current().childLaneOption || "breadcrumb",   // "breadcrumb" or "full"
 
  // Colors & Priority
  overdueSuffix: dv.current().roadmapOverdueSuffix || " overdue",
  overdueFlag: dv.current().roadmapOverdueFlag || "red",
  priorityColors: {
    Highest: "red",
    High:    "orange",
    Medium:  "blue",
    Low:     "green",
    Lowest:  "cyan"
  },
  doneColor:    "gray",     // or "green" if you prefer
  cancelledColor: "gray",   // or "red" if you prefer
 
  // Additional toggles
  topLevelCrit: dv.current().topLevelCrit !== false,  // not as relevant in Chronos, but kept for reference
  onlyOneDateAsPoint: true,  // if a task has only a start OR due, treat as a Chronos point
 
  // Subtasks -> description
  // If true, nested bullet lines under tasks become part of the "description" in Chronos (the text after "|")
  // The script will gather them up into a bullet list or single line
  captureSubtasks: true,   
 
  // Order & DefaultView
  defaultViewStart: dv.current().ganttStart || "",
  defaultViewEnd:   dv.current().ganttEnd   || "",
  // Chronos syntax example:   > DEFAULTVIEW 2025|2030
 
  // Quarter Markers
  showQuarters: dv.current().showQuarters !== false,
  // "top" or "bottom" for whether to put these Q# lines in the code or not 
  // (Chronos doesn't have a built-in concept of top/bottom, but we can place them as markers or points)
  quarterPlacement: "markers",   // "markers" or "points"
};
 
// Priority mapping based on emojis
const priorityMap = {
  "🔺": "Highest",
  "⏫": "High",
  "🔼": "High",    // optional, if you also use these emojis
  "⏺️": "Medium",
  "🔽": "Low",
  "⏬": "Lowest"
};
 
// A helper to detect priority from text
function getPriority(text) {
  for (let emoji in priorityMap) {
    if (text.includes(emoji)) return priorityMap[emoji];
  }
  return "";
}
 
// A helper to parse #roadmap markers
function parseRoadmapMarkers(text) {
  // up to 4 levels
  const roadmapRegex = /#roadmap(?:\/([\w-]+))?(?:\/([\w-]+))?(?:\/([\w-]+))?(?:\/([\w-]+))?/;
  let lane = config.defaultLane;
  let childChain = [];
  let match = text.match(roadmapRegex);
  if (match) {
    if (match[1]) lane = match[1];
    for (let i = 2; i < match.length; i++) {
      if (match[i]) childChain.push(match[i]);
    }
  }
  return {lane, childChain};
}
 
// Function that extracts a sub-bullet list for a given task, if desired.
function collectSubtaskDescription(task) {
  if (!config.captureSubtasks || !task.subtasks) return "";
  // Let's build a bullet list of subtask lines
  // This can be refined to skip completed or do something else
  let lines = [];
  for (let s of task.subtasks) {
    // skip if done or not, your choice
    lines.push("- " + s.text);
  }
  if (lines.length > 0) {
    return "" + lines.join(". ");
  }
  return "";
}
 
// A small helper to see if a task is "done" or "cancelled".
function getTaskStatus(task) {
  // typical tasks plugin statuses might be "done", "cancelled", etc.
  if (task.status === "done") return "done";
  if (task.status === "cancelled") return "cancelled";
  return "pending";
}
 
// A helper to convert an Obsidian Task date to an ISO date string for Chronos
function toChronosDate(obsidianDate) {
  // ex: 2025-01-23
  // Chronos supports YYYY, YYYY-MM, etc. We'll just produce YYYY-MM-DD
  return obsidianDate.toString().split("T")[0];
}
 
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
 
// MAIN CODE -------------------------------------------------------------------
 
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
 
// Query tasks (#roadmap or #ganttchart or anything you want):
const tasks = dv.pages("")
  .file.tasks
  .where(t => 
    (t.text.includes("#roadmap") || t.text.includes("#timeline")) 
    && !t.completed
  );
 
// We'll store lines in a big array, then  join them at the end
let lines = [];
 
// We might add some optional flags for Chronos at the top. 
// e.g. > ORDERBY start
// or a default view if config.defaultViewStart & config.defaultViewEnd
// or a color scheme
let topFlags = [];
 
if (config.defaultViewStart && config.defaultViewEnd) {
  topFlags.push(`DEFAULTVIEW  ${config.defaultViewStart}|${config.defaultViewEnd}`);
} 
 
// For ordering, you can decide how to handle. Let's do nothing by default:
topFlags.push(`ORDERBY start`);
 
//////////////////////////////////////
// Process each task => Chronos items
//////////////////////////////////////
for (let t of tasks) {
  // We assume "start" is t.start, "due" is t.due
  let start = t.start ? toChronosDate(t.start) : "";
  let end   = t.due   ? toChronosDate(t.due)   : "";
  
  // Get the text and parse lane markers
  let rawText = t.text;
  let {lane, childChain} = parseRoadmapMarkers(rawText);
 
  // Compute priority from emojis
  let prio = getPriority(rawText);
 
  // Also handle "done" or "cancelled" from tasks
  let localStatus = getTaskStatus(t); // e.g. "done", "cancelled", "pending"
  // We'll map that to a color or so
  let color = "";
  if (localStatus === "done") {
    color = `#${config.doneColor}`;
  } else if (localStatus === "cancelled") {
    color = `#${config.cancelledColor}`;
  } else if (prio && config.priorityColors[prio]) {
    color = `#${config.priorityColors[prio]}`; 
    // for instance, #red, #blue, #green, etc.
  }
 
  // For the final lane name if "childLaneOption" is "full"
  // or keep it as the root and append childChain to the item label
  let laneBreadcrumb = "";
  let itemTitle = rawText;
  // Remove the #roadmap... stuff from itemTitle:
  itemTitle = itemTitle.replace(/#[\w\/-]+/g, "").trim();
  // Remove common marker emojis.
  itemTitle = itemTitle.replace(/[🚩🔺⏫⏺️🔽⏬➕🛫📅]/g, "");
  // Remove inline dates (YYYY-MM-DD).
  itemTitle = itemTitle.replace(/\d{4}-\d{2}-\d{2}/g, "");
 
  // Optionally parse the " dash " in the text to separate title & desc
  // If we want: "Title - desc text"
  let dashIndex = itemTitle.indexOf(" - ");
  let desc = "";
  if (dashIndex > 0) {
    desc = itemTitle.slice(dashIndex + 3).trim();
    itemTitle = itemTitle.slice(0, dashIndex).trim();
  }
 
  // If capturing sub-bullets as well, append to desc
  if (config.captureSubtasks) {
    let subDesc = collectSubtaskDescription(t);
    if (subDesc) {
      desc += (desc ? "\n" : "") + subDesc;
    }
  }
 
  // If groupMode is "full"
  if (config.groupMode === "full" && childChain.length > 0) {
    lane = lane + "/" + childChain.join(" > ");
  } 
  // else if breadcrumb, we do nothing special to lane, but we add childChain to the itemTitle
  else if (config.groupMode === "breadcrumb" && childChain.length > 0) {
    itemTitle += ` (${childChain.join(" > ")})`;
  }
 
  // If the task has both start & end => treat as "Event"  => leading char is `-`
  // If only one => treat as "Point" => leading char is `*` or `=` or `@` if you want a period
  // But let's do "point" = single date, "event" = range, "period" = there's an option to treat it as a "period"
 
  // We'll default to events, but if only one date is present, we do a point
  let timelineChar = "-";
  let hasBoth = (start && end);
  let sDateForChronos = `[${start}]`;
  // if we have a range
  if (hasBoth) {
    // if they differ, we do [start~end]
    if (start !== end) {
      sDateForChronos = `[${start}~${end}]`;
    }
  }
  else {
    // only has 1 date => point
    timelineChar = "*";
    // pick whichever is non-empty
    sDateForChronos = `[${start || end}]`;
  }
 
  // next we do color and grouping
  // Chronos syntax: - [dateRange] #color {Group Name} Title | desc
  let groupPart = lane ? `{${lane}}` : "";
  let colorPart = color ? `${color}` : "";  // e.g. "#red"
 
  let finalLabel = "";
  if (desc) {
    finalLabel = `${itemTitle} | ${desc}`;
  } else {
    finalLabel = itemTitle; // no desc
  }
 
  // Put it all together
  // e.g.:  - [2025-01-05~2025-01-15] #red {dfir} My Title | some desc
  // You can skip the group if you don't want them as groups, or if Chronos's grouping is optional
  // Also note that if you put a color, it must come before the group in Chronos syntax
  let lineParts = [];
  lineParts.push(`${timelineChar} ${sDateForChronos}`);
  if (colorPart) lineParts.push(colorPart);
  if (groupPart) lineParts.push(groupPart);
  lineParts.push(finalLabel);
 
  // join them with a space
  let finalLine = lineParts.join(" ");
 
  lines.push(finalLine);
} // end tasks loop
 
/////////////////////////////////////////////////////////
// Build up the final Chronos code block
/////////////////////////////////////////////////////////
let chronosLines = [];
chronosLines.push("```chronos");
 
// Insert any topFlags like DEFAULTVIEW or ORDERBY:
for (let f of topFlags) {
  chronosLines.push(`> ${f}`);
}
 
// Optional: If we want user color or grouping examples, we can add them here
if (config.defaultViewStart && config.defaultViewEnd) {
  // example: > DEFAULTVIEW 2025|2026
  // It's already done in topFlags
}
 
// Insert quarter markers if desired, as Markers or Points. 
// If showQuarters => we can do something like:
if (config.showQuarters && config.ganttStart && config.ganttEnd) {
	 console.log(`${showQuarters} - ${ganttStart} - ${ganttEnd}`)
  let startYear = Number(moment(config.ganttStart, config.dateFormat).format("YYYY"));
  let endYear   = Number(moment(config.ganttEnd, config.dateFormat).format("YYYY"));
  if (startYear === endYear) {
    // e.g. Q1, Q2, Q3, Q4 as markers or points
    // We'll do markers with single date: e.g. = [year-03-31] Q1
    // or we do a period or event, up to you
    let q1 = moment(config.ganttStart, config.dateFormat).month(2).endOf("month").format("YYYY-MM-DD");
    let q2 = moment(config.ganttStart, config.dateFormat).month(5).endOf("month").format("YYYY-MM-DD");
    let q3 = moment(config.ganttStart, config.dateFormat).month(8).endOf("month").format("YYYY-MM-DD");
    let q4 = moment(config.ganttStart, config.dateFormat).month(11).endOf("month").format("YYYY-MM-DD");
    // If we want them at the top, put them at the start of lines array
    // If you want them at the bottom, push them last
    // We'll just add them first here:
    lines.unshift(`= [${q4}] Q4`);
    lines.unshift(`= [${q3}] Q3`);
    lines.unshift(`= [${q2}] Q2`);
    lines.unshift(`= [${q1}] Q1`);
  }
}
 
// Now let's push all lines
chronosLines.push(...lines);
 
// Done. Close code block
chronosLines.push("```");
 
const chronosContent = chronosLines.join("\n")
 
console.log(chronosContent);
 
dv.paragraph(chronosContent);