sailfork / t3code-github / apps/ mobile/ src/ state/ pending-new-tasks-model.ts

import type { EnvironmentId, ProjectId } from "@t3tools/contracts";

import { deriveThreadTitleFromPrompt } from "../lib/projectThreadStartTurn";
import type { QueuedThreadCreation, QueuedThreadMessage } from "./thread-outbox-model";
import { isNewTaskDraftKey } from "./new-task-draft-key";
import type { ComposerDraft } from "./use-composer-drafts";
import { resolveNewTaskDraftWorkspace } from "../features/threads/new-task-context-presentation";

export type PendingNewTask = PendingQueuedTask | PendingDraftTask;

export interface PendingQueuedTask {
  readonly kind: "pending";
  readonly key: string;
  readonly environmentId: EnvironmentId;
  readonly projectId: ProjectId;
  readonly projectTitle: string | undefined;
  readonly projectCwd: string | undefined;
  readonly branch: string | null;
  readonly title: string;
  readonly createdAt: string;
  readonly message: QueuedThreadMessage;
  readonly creation: QueuedThreadCreation;
}

export interface PendingDraftTask {
  readonly kind: "draft";
  readonly key: string;
  readonly environmentId: EnvironmentId;
  readonly projectId: ProjectId;
  readonly projectTitle: undefined;
  readonly projectCwd: undefined;
  readonly title: string;
  readonly createdAt: string;
  readonly draftKey: string;
  readonly draft: ComposerDraft;
}

function composerDraftHasUserContent(draft: ComposerDraft): boolean {
  return draft.text.trim().length > 0 || draft.attachments.length > 0;
}

function draftTitle(draft: ComposerDraft): string {
  if (draft.text.trim().length > 0) {
    return deriveThreadTitleFromPrompt(draft.text);
  }
  const count = draft.attachments.length;
  return count === 1 ? "1 attachment" : `${count} attachments`;
}

/** A project's new-task defaults, as useNewTaskProjectDefaults resolves them. */
export interface PendingDraftProjectDefaults {
  readonly canChooseWorkspace: boolean;
  readonly defaultMode: "local" | "worktree";
  readonly defaultModeSettled: boolean;
}

/**
 * True when the draft's branch is derived from refs rather than stored, so the list must load
 * refs to show it.
 */
export function pendingDraftBranchNeedsRefs(
  draft: ComposerDraft,
  defaults: PendingDraftProjectDefaults,
): boolean {
  const selection = defaults.canChooseWorkspace ? draft.workspaceSelection : undefined;
  return selection === undefined ? defaults.defaultMode === "worktree" : selection.branch === null;
}

/** The branch a draft will start on, derived the same way the new-task flow and send path do. */
export function resolvePendingDraftBranch(input: {
  readonly draft: ComposerDraft;
  readonly defaults: PendingDraftProjectDefaults;
  readonly isGitRepo: boolean;
  readonly branches: Parameters<typeof resolveNewTaskDraftWorkspace>[0]["branches"];
  readonly projectCwd: string | null;
}): string | null {
  return resolveNewTaskDraftWorkspace({
    selection: input.draft.workspaceSelection,
    canChooseWorkspace: input.defaults.canChooseWorkspace,
    defaultMode: input.defaults.defaultMode,
    defaultModeSettled: input.defaults.defaultModeSettled,
    isGitRepo: input.isGitRepo,
    branches: input.branches,
    projectCwd: input.projectCwd,
  }).branch;
}

export function buildPendingNewTasks(input: {
  readonly queuedMessages: ReadonlyArray<QueuedThreadMessage>;
  readonly drafts: Readonly<Record<string, ComposerDraft>>;
}): ReadonlyArray<PendingNewTask> {
  const tasks: PendingNewTask[] = [];
  for (const message of input.queuedMessages) {
    if (!message.creation) {
      continue;
    }
    tasks.push({
      kind: "pending",
      key: `pending-task:${message.messageId}`,
      environmentId: message.environmentId,
      projectId: message.creation.projectId,
      projectTitle: message.creation.projectTitle,
      projectCwd: message.creation.projectCwd,
      branch: message.creation.branch,
      title: deriveThreadTitleFromPrompt(message.text),
      createdAt: message.createdAt,
      message,
      creation: message.creation,
    });
  }
  for (const [draftKey, draft] of Object.entries(input.drafts)) {
    if (!isNewTaskDraftKey(draftKey) || !draft.project || !composerDraftHasUserContent(draft)) {
      continue;
    }
    tasks.push({
      kind: "draft",
      key: `draft-task:${draftKey}`,
      environmentId: draft.project.environmentId,
      projectId: draft.project.projectId,
      projectTitle: undefined,
      projectCwd: undefined,
      title: draftTitle(draft),
      createdAt: draft.project.createdAt,
      draftKey,
      draft,
    });
  }
  tasks.sort((left, right) => {
    if (left.kind !== right.kind) {
      return left.kind === "draft" ? -1 : 1;
    }
    return right.createdAt.localeCompare(left.createdAt) || left.key.localeCompare(right.key);
  });
  return tasks;
}