task-placement.ts

import { normalizeHeadingName } from "./headings.js";

type ItemType = "to-do" | "project" | "heading";
type ItemStatus = "incomplete" | "canceled" | "completed";
type StartBucket = "Inbox" | "Anytime" | "Someday" | "";

type ChecklistItem = {
  id: string;
  title: string;
  status: ItemStatus;
  stopDate: string | null;
};

type TaskLike = {
  id: string;
  type: ItemType;
  title: string;
  status: ItemStatus;
  trashed: boolean;
  notes: string;
  start: StartBucket;
  startDate: string | null;
  deadline: string | null;
  deadlineSuppressed: boolean;
  stopDate: string | null;
  created: string | null;
  modified: string | null;
  areaId: string | null;
  areaTitle: string | null;
  projectId: string | null;
  projectTitle: string | null;
  headingId: string | null;
  headingTitle: string | null;
  tags: string[];
  checklist: ChecklistItem[];
  index: number;
  todayIndex: number;
};

const STOPWORDS = new Set([
  "de", "la", "el", "los", "las", "y", "en", "para", "con", "por", "del",
  "the", "and", "for", "with", "to", "a", "an", "of", "on", "or"
]);

function tokenize(value: string) {
  return value
    .toLowerCase()
    .normalize("NFD")
    .replace(/[\u0300-\u036f]/g, "")
    .replace(/[^a-z0-9\s]/g, " ")
    .split(/\s+/)
    .filter((token) => token.length > 1 && !STOPWORDS.has(token));
}

function buildHeadingCorpus(headings: TaskLike[], todos: TaskLike[]) {
  return headings.map((heading) => {
    const ownTodos = todos.filter((todo) => todo.headingId === heading.id);
    const tokens = new Set<string>([
      ...tokenize(heading.title),
      ...tokenize(normalizeHeadingName(heading.title)),
    ]);

    for (const todo of ownTodos) {
      for (const token of tokenize(todo.title)) {
        tokens.add(token);
      }
    }

    return {
      headingId: heading.id,
      headingTitle: heading.title,
      ownTodoCount: ownTodos.length,
      tokens,
    };
  });
}

export function suggestTaskPlacement(input: {
  projectTitle: string;
  headings: TaskLike[];
  todos: TaskLike[];
  taskTitles: string[];
}) {
  const corpora = buildHeadingCorpus(input.headings, input.todos);

  const placements = input.taskTitles.map((taskTitle) => {
    const taskTokens = tokenize(taskTitle);
    const scored = corpora
      .map((heading) => {
        let score = 0;
        const matches: string[] = [];

        for (const token of taskTokens) {
          if (heading.tokens.has(token)) {
            score += 3;
            matches.push(token);
          }
        }

        const normalizedHeading = normalizeHeadingName(heading.headingTitle);
        if (taskTitle.toLowerCase().includes(normalizedHeading)) {
          score += 4;
          matches.push(heading.headingTitle);
        }

        if (heading.ownTodoCount > 0 && score > 0) {
          score += 1;
        }

        return {
          headingId: heading.headingId,
          headingTitle: heading.headingTitle,
          score,
          matches: [...new Set(matches)],
        };
      })
      .sort((a, b) => b.score - a.score || a.headingTitle.localeCompare(b.headingTitle));

    const best = scored[0];
    const second = scored[1];
    const ambiguous = Boolean(best && second && best.score > 0 && best.score === second.score);
    const confident = Boolean(best && best.score >= 3 && !ambiguous);

    return {
      taskTitle,
      suggestedHeadingId: confident ? best.headingId : null,
      suggestedHeadingTitle: confident ? best.headingTitle : null,
      confidence: confident ? (best.score >= 6 ? "high" : "medium") : "low",
      ambiguous,
      reason: confident
        ? `Coincide mejor con ${best.headingTitle}${best.matches.length ? ` por: ${best.matches.join(", ")}` : ""}.`
        : ambiguous
          ? "La tarea podría encajar en más de un heading existente."
          : "No hay una coincidencia semántica suficientemente clara con los headings existentes.",
      alternatives: scored
        .filter((entry) => entry.score > 0)
        .slice(0, 3)
        .map(({ headingId, headingTitle, score }) => ({ headingId, headingTitle, score })),
    };
  });

  return {
    projectTitle: input.projectTitle,
    headings: corpora.map(({ headingId, headingTitle, ownTodoCount }) => ({
      headingId,
      headingTitle,
      ownTodoCount,
    })),
    placements,
    summary: {
      totalTasks: placements.length,
      confidentlyPlaced: placements.filter((entry) => entry.suggestedHeadingId).length,
      needsReview: placements.filter((entry) => !entry.suggestedHeadingId).length,
    },
    guidance:
      "Usa estas sugerencias para reutilizar los headings existentes del proyecto. Si una tarea queda con confianza baja o ambigua, conviene confirmar con el usuario antes de moverla.",
  };
}