Add to Habitify from Todoist w/ AI

import { blob } from "https://esm.town/v/std/blob";
import process from "node:process";
import { TodoistApi } from "npm:@doist/todoist-api-typescript";
import Instructor from "npm:@instructor-ai/instructor";
import Jimp from "npm:jimp";
import OpenAI from "npm:openai";
import { z } from "npm:zod";

const force_update_database = false; // set force update database to true
// if you added new items to habitify after running this script
// for the first time.

// INST: Add these keys in val env variables
// NOTE: the image notes don't work at the moment, and if you add a image note,
// the task is skipped

const TODOIST_API_KEY = process.env.TODOIST_API_KEY;
const HABITIFY_API_KEY = process.env.HABITIFY_API_KEY;
const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const DEF_TIMEZONE = "America/Los_Angeles"; // Get your timezone from here: https://stackoverflow.com/a/54500197

var add_to_habitify_todoist_project_id = "XXXX"; // INST: Project ID goes here
var todoist_dict_mapping = { // Note: You can choose to leave this dict empty and it will still work
  "Image Notes": { // This is for a section that is image notes only for any habit without adding a log
    "todoist-section-id": "XXXX", // INST: section id for just image notes section goes here
    "habitify-area-name": "undefined", // keep this value as undefined
    specialPrompt: "only_image", // keep the value as only_image
  },
  "Text Notes": { // This is for a section that is text notes only for any habit without adding a log
    "habitify-area-name": "undefined", // keep this value as undefined
    "todoist-section-id": "XXXX", // INST: section id for just image notes section goes here
    specialPrompt: "only_text", // keep the value as only_text
  },
  Cats: {
    "todoist-section-id": "XXXX", // section id for the area goes here
    "habitify-area-name": "Cats", // INST: habitify area name goes here. Match exactly
    specialPrompt: "", // keep the value as empty text
  },
  Food: { // You do not need to have a section that tracks calories, it is just a bonus
    "todoist-section-id": "XXXX", // section id for the area goes here
    "habitify-area-name": "Health", // INST: habitify area name goes here. Match exactly
    specialPrompt: "track_calories", // keep the value as track_calories if you want to
    // estimate calories based on entry. the estimation is pretty wild and can vary by +/- 500 kCal at least
  },
  // ADD any other sections as areas here to help the model choose amongst less habits.
  // Keep specialPrompt value as empty strng
};

const todoistapi = new TodoistApi(TODOIST_API_KEY);

const oai = new OpenAI({
  apiKey: OPENAI_API_KEY ?? undefined,
});

const client = Instructor({
  client: oai,
  mode: "TOOLS",
});

function getHabitifyAreaName(section_id) {
  if (!section_id) {
    return ["undefined", ""];
  }

  for (var key in todoist_dict_mapping) {
    if (todoist_dict_mapping[key]["todoist-section-id"] === section_id) {
      return [
        todoist_dict_mapping[key]["habitify-area-name"],
        todoist_dict_mapping[key]["specialPrompt"].toLowerCase(),
      ];
    }
  }

  return ["undefined", ""];
}

function convertDateObject(due) {
  function convertToISOWithOffset(datetimeStr, timezoneStr) {
    const date = new Date(datetimeStr);
    const [, sign, hours, minutes] = timezoneStr.match(
      /GMT ([+-])(\d{1,2}):(\d{2})/,
    );
    date.setUTCMinutes(
      date.getUTCMinutes()
        + (parseInt(hours) * 60 + parseInt(minutes)) * (sign === "+" ? 1 : -1),
    );
    return (
      date.toISOString().split(".")[0]
      + `${sign}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`
    );
  }
  const formatDate = (date, datetime, timezone) => {
    let isoString = datetime ? datetime : date;
    if (timezone && timezone.startsWith("GMT") && timezone.length > 3) {
      return convertToISOWithOffset(datetime, timezone);
    } else {
      return isoString;
    }
  };

  const date_as_string = due
    ? formatDate(due.date, due.datetime, due.timezone)
    : new Date().toISOString();

  return date_as_string;
}
async function getCommentsForTask(taskId) {
  try {
    const comments = await todoistapi.getComments({ taskId });
    return comments;
  } catch (error) {
    console.error(`Error fetching comments for task ${taskId}:`, error);
    return [];
  }
}

async function resizeAndConvertImage(imageBuffer) {
  try {
    const image = await Jimp.read(imageBuffer);
    const resizedImage = await image.resize(800, 800, Jimp.RESIZE_BILINEAR);
    const jpegBuffer = await resizedImage.quality(80).getBufferAsync(Jimp.MIME_JPEG);

    if (jpegBuffer.length >= 2000000) {
      console.error("Error: Resized image size should be smaller than 2MB");
      return null;
    }

    return jpegBuffer;
  } catch (error) {
    console.error("Error processing image:", error);
    return null;
  }
}

async function downloadImage(url) {
  try {
    const response = await fetch(url, {
      headers: {
        Authorization: `Bearer ${TODOIST_API_KEY}`,
      },
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const imageBuffer = await response.buffer();
    const resizedImageBuffer = await resizeAndConvertImage(imageBuffer);

    return resizedImageBuffer;
  } catch (error) {
    console.error("Error downloading or processing image:", error);
    return null;
  }
}

async function createZodSchema(habitKeys, specialPrompt) {
  const transformDate = (date) => {
    if (!date.includes("T")) {
      date = date + "T23:00:00"; // if no time is included, consider it completed at 11pm
    }
    const parsedDate = Date.parse(date);
    const dateObj = isNaN(parsedDate) ? new Date() : new Date(parsedDate);

    const pad = (num) => String(num).padStart(2, "0");

    const year = dateObj.getFullYear();
    const month = pad(dateObj.getMonth() + 1);
    const day = pad(dateObj.getDate());
    const hours = pad(dateObj.getHours());
    const minutes = pad(dateObj.getMinutes());
    const seconds = pad(dateObj.getSeconds());
    // console.log(date);

    let offsetSign, offsetHours, offsetMinutes;
    const [datePart, timePart] = date.split("T");

    if (
      date.endsWith("Z")
      || !timePart
      || (timePart && !timePart.includes("+") && !timePart.includes("-"))
    ) {
      // Create a DateTimeFormat object for Pacific Time
      const pacificTime = new Intl.DateTimeFormat("en-US", {
        timeZone: DEF_TIMEZONE,
        hour: "2-digit",
        minute: "2-digit",
        second: "2-digit",
        hour12: false,
      });

      // Format the date to get the correct Pacific Time offset
      const pacificParts = pacificTime.formatToParts(dateObj);
      const pacificHours = parseInt(
        pacificParts.find((p) => p.type === "hour").value,
        10,
      );
      const pacificMinutes = parseInt(
        pacificParts.find((p) => p.type === "minute").value,
        10,
      );

      // Calculate the offset in minutes between the local time and UTC
      let offset = (pacificHours - dateObj.getUTCHours()) * 60
        + (pacificMinutes - dateObj.getUTCMinutes());

      // Adjust for day boundary crossing
      if (offset > 720) {
        offset -= 1440; // Subtract a full day in minutes
      } else if (offset < -720) {
        offset += 1440; // Add a full day in minutes
      }
      const absOffset = Math.abs(offset);
      offsetHours = pad(Math.floor(absOffset / 60));
      offsetMinutes = pad(absOffset % 60);
      offsetSign = offset <= 0 ? "-" : "+";
    } else {
      const offset = dateObj.getTimezoneOffset();
      const absOffset = Math.abs(offset);
      offsetHours = pad(Math.floor(absOffset / 60));
      offsetMinutes = pad(absOffset % 60);
      offsetSign = offset <= 0 ? "+" : "-";
    }

    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${offsetSign}${offsetHours}:${offsetMinutes}`;
  };

  let habitSchema;

  if (specialPrompt === "only_text" || specialPrompt === "only_image") {
    habitSchema = z.object({
      name: z.enum(habitKeys),
      note: z.string().default(""),
      date: z.string().transform(transformDate),
    });
  } else if (
    specialPrompt
    && (specialPrompt.includes("calorie") || specialPrompt.includes("food intake"))
  ) {
    habitSchema = z.object({
      unit: z.string().default("kCal"),
      name: z.enum(habitKeys),
      value: z.number().default(1),
      note: z.string().default(""),
      date: z.string().transform(transformDate),
    });
  } else {
    habitSchema = z.object({
      unit: z.string().default("rep"),
      name: z.enum(habitKeys),
      value: z.number().default(1),
      note: z.string().default(""),
      date: z.string().transform(transformDate),
    });
  }

  // Define the schema for the list of habits
  const habitsListSchema = z.array(habitSchema);

  return z.object({ habits: habitsListSchema });
}
function createPrompt(habitKeys_str, specialPrompt) {
  let prompt =
    "You are processing content into a list of habit objects. Based on the options of habits, infer appropriate values for the fields:\n";
  prompt += "The habits you can choose from are: " + habitKeys_str + ".\n";

  if (specialPrompt === "only_image" || specialPrompt === "only_text") {
    prompt +=
      "You are extracting the name of the habit, the date of the habit (if mentioned, or otherwise an empty string), and any note if it exists about a habit (if mentioned, or otherwise an empty string). Remember, a note is associated with only 1 habit and will say 'note that' or something like that.\n";
  } else if (
    specialPrompt
    && (specialPrompt.includes("calorie") || specialPrompt.includes("food intake"))
  ) {
    prompt +=
      "You are tracking habits related to calorie or food intake. You are extracting the name of the habit which will be something like 'track calories' or 'track food intake'. As the next step, estimate the calories for the food mentioned in the text as and use that as the value, the unit will be kCal, the date of the habit (if mentioned, or otherwise an empty string), and the food mentioned in the text will be the note for the habit along with the estimated calories in paranthesis.\n";
  } else {
    prompt +=
      "You are choosing the unit (like min or kg), the default is rep. You are choosing the value of the habit, the default is 1. You are getting the date of the habit, if mentioned, or otherwise an empty string. You are extracting any note if it exists about a habit, if mentioned, or otherwise an empty string. Remember, a note is associated with only 1 habit and will say 'note that' or something like that.\n";
  }

  prompt += "Infer and in step 1 ";
  prompt = prompt
    + (specialPrompt
        && (specialPrompt.includes("calorie") || specialPrompt.includes("food intake"))
      ? "a list with a SINGLE habit object that matches the calorie or food intake option from valid options"
      : "create a list of all the habits extracted from text that match the options")
    + "; and then as step 2 assign values to each of these habits' properties based on the provided content and the aforementioned context.";
  return prompt;
}
async function process_text(habits_list, text, specialPrompt) {
  // console.log(habits_list);
  const habitKeys = Object.keys(habits_list);
  const zod_schema = await createZodSchema(habitKeys, specialPrompt);

  const sys_prompt = createPrompt(habitKeys.join(), specialPrompt);
  const processed_message = await client.chat.completions.create({
    messages: [
      { role: "system", content: sys_prompt },
      { role: "user", content: text },
    ],
    model: "gpt-4o",
    response_model: {
      schema: zod_schema,
      name: "habit and value extraction",
    },
    max_retries: 3,
  });

  return processed_message;
}

async function addLog(habit_id, unit_type, value, target_date) {
  const url = `https://api.habitify.me/logs/${habit_id}`;
  const headers = {
    Authorization: HABITIFY_API_KEY,
    "Content-Type": "application/json",
  };
  const body = {
    unit_type: unit_type,
    value: value,
    target_date: target_date,
  };

  try {
    const response = await fetch(url, {
      method: "POST",
      headers: headers,
      body: JSON.stringify(body),
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const jsonResponse = await response.json();
    return jsonResponse;
  } catch (error) {
    console.error("Error:", error);
    process.exit(1);
  }
}
async function addTextNote(habit_id, created, content) {
  const url = `https://api.habitify.me/notes/${habit_id}`;
  const headers = {
    Authorization: HABITIFY_API_KEY,
    "Content-Type": "application/json",
  };
  const body = {
    created: created,
    content: content,
  };

  try {
    const response = await fetch(url, {
      method: "POST",
      headers: headers,
      body: JSON.stringify(body),
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const jsonResponse = await response.json();
    return jsonResponse;
  } catch (error) {
    console.error("Error:", error);
    process.exit(1);
  }
}

async function addImageNote(habit_id, created_at, imageBuffer) {
  const url = `https://api.habitify.me/notes/addImageNote/${habit_id}?created_at=${encodeURIComponent(created_at)}`;
  const headers = {
    Authorization: HABITIFY_API_KEY,
    "Content-Type": "image/jpeg",
  };

  try {
    const response = await fetch(url, {
      method: "POST",
      headers: headers,
      body: imageBuffer,
    });
    if (!response.ok) {
      console.log(response);
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const jsonResponse = await response.json();
    return jsonResponse;
  } catch (error) {
    console.error("Error:", error);
    process.exit(1);
  }
}

async function get_habitify_database()
{
  const habits_list = await blob.getJSON("habitify_database");
  if (!habits_list || force_update_database)
  {
    const HABITIFY_API_KEY = process.env.HABITIFY_API_KEY;
    const url = "https://api.habitify.me/habits";
    const headers = {
      Authorization: HABITIFY_API_KEY,
      "Content-Type": "application/json",
    };

    try {
      const response = await fetch(url, { method: "GET", headers: headers });
      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }
      const jsonResponse = await response.json();

      // Filter habits
      const filteredHabits = jsonResponse.data.filter(
        (habit) => !habit.is_archived && habit.log_method === "manual",
      );

      // Group habits by area
      const habitsByArea = {};
      filteredHabits.forEach((habit) => {
        const area = habit.area && Object.keys(habit.area).length > 0
          ? habit.area.name
          : "undefined";
        if (!habitsByArea[area]) {
          habitsByArea[area] = {};
        }
        habitsByArea[area][habit.name] = {
          id: habit.id,
          name: habit.name,
          unit_type: habit.goal.unit_type,
        };
        if (area !== "undefined") {
          if (!habitsByArea["undefined"]) {
            habitsByArea["undefined"] = {};
          }
          habitsByArea["undefined"][habit.name] = {
            id: habit.id,
            name: habit.name,
            unit_type: habit.goal.unit_type,
          };
        }
      });
      // Log the result JSON
      console.log(JSON.stringify(habitsByArea, null, 2));
      await blob.setJSON("habitify_database", habitsByArea);
      return habitsByArea;
    } catch (error) {
      console.error("Error:", error);
      process.exit(1);
    }
  }
  else
  {
    return habits_list;
  }
}

export default async function(interval: Interval) {
  const habits_list = await get_habitify_database();
  var tasks = await todoistapi.getTasks({
    projectId: add_to_habitify_todoist_project_id,
  });

  for (const task of tasks) {
    console.log(task);
    task.imageComments = null;
    if (task.commentCount > 0) {
      const imageComments = [];
      const todoist_comments = await getCommentsForTask(task.id);
      for (const comment of todoist_comments) {
        // console.log(comment);
        if (comment.attachment && comment.attachment.resourceType === "image") {
          const imageBuffer = await downloadImage(comment.attachment.image);
          if (imageBuffer) {
            imageComments.push(imageBuffer);
          }
        }
      }
      task.imageComments = imageComments ? imageComments : null;
    }

    /// START---REMOVE ONCE UPLOAD IS FIXED
    if (task.imageComments) {
      continue;
    }
    /// END---REMOVE ONCE UPLOAD IS FIXED

    const [habitifyAreaName, specialPrompt] = getHabitifyAreaName(
      task.sectionId,
    );
    const processed_task = await process_text(
      habits_list[habitifyAreaName],
      task.content
        + " dated "
        + convertDateObject(task.due)
        + "\n"
        + task.description,
      specialPrompt,
    );
    const habits = processed_task.habits;
    console.log(habits);
    for (const habit of habits) {
      if (specialPrompt != "only_image" || specialPrompt != "only_text") {
        await addLog(
          habits_list[habitifyAreaName][habit.name].id,
          habit.unit,
          habit.value,
          habit.date,
        );
      }
      if (habit.note) {
        await addTextNote(habits_list[habitifyAreaName][habit.name].id, habit.date, habit.note);
      }
      if (task.imageComments) {
        for (const imageComment of task.imageComments) {
          await addImageNote(
            habits_list[habitifyAreaName][habit.name].id,
            habit.date,
            imageComment,
          );
        }
      }
    }
    await todoistapi.deleteTask(task.id);
  }
}