Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

18.4 KB
Raw Blame
import {
  type StoredComposerMigration,
  type StoredElementContext,
  type StoredTerminalContext,
} from "./draftMigrationSchemas";
import * as Predicate from "effect/Predicate";
import {
  DEFAULT_LOCAL_EXECUTION_MODE,
  EnvironmentId,
  ModelSelection,
  ProjectId,
  ProviderInstanceId,
  ThreadId,
} from "@akeru/contracts";
import {
  parseScopedProjectKey,
  parseScopedThreadKey,
  scopeProjectRef,
  scopeThreadRef,
} from "@akeru/client-runtime/environment";
import { DeepMutable } from "effect/Types";
import { DEFAULT_INTERACTION_MODE } from "../types";
import { ensureInlineTerminalContextPlaceholders } from "../lib/terminalContext";
import {
  type PersistedComposerImageAttachment,
  type PersistedElementContextDraft,
  type PersistedTerminalContextDraft,
  type PersistedComposerDraftStoreState,
  type PersistedDraftThreadState,
} from "./draftPersistenceSchemas";
import {
  normalizeLegacyComposerStorageKey,
  projectDraftKey,
  normalizeDraftThreadEnvMode,
  composerThreadRefFromKey,
} from "./draftIdentity";
import { isRuntimeMode } from "./draftTypes";
import {
  normalizeProviderInstanceId,
  normalizeProviderModelOptions,
  normalizeModelSelection,
  legacyMergeModelSelectionIntoProviderModelOptions,
  legacySyncModelSelectionOptions,
  legacyToModelSelectionByProvider,
  compactModelSelectionByProvider,
} from "./draftModelSelection";

function normalizePersistedAttachment(
  value: PersistedComposerImageAttachment | null,
): PersistedComposerImageAttachment | null {
  if (!Predicate.isObjectOrArray(value)) {
    return null;
  }

  const candidate = value;
  const id = candidate.id;
  const name = candidate.name;
  const mimeType = candidate.mimeType;
  const sizeBytes = candidate.sizeBytes;
  const dataUrl = candidate.dataUrl;

  if (
    !Predicate.isString(id) ||
    !Predicate.isString(name) ||
    !Predicate.isString(mimeType) ||
    !Predicate.isNumber(sizeBytes) ||
    !Number.isFinite(sizeBytes) ||
    !Predicate.isString(dataUrl) ||
    id.length === 0 ||
    dataUrl.length === 0
  ) {
    return null;
  }

  return {
    id,
    name,
    mimeType,
    sizeBytes,
    dataUrl,
  };
}

function normalizePersistedElementContextDraft(
  value: StoredElementContext | null,
): PersistedElementContextDraft | null {
  if (!Predicate.isObjectOrArray(value)) return null;
  const candidate = value;
  const id = candidate.id;
  const threadId = candidate.threadId;
  const pickedAt = candidate.pickedAt;
  const pageUrl = candidate.pageUrl;
  const tagName = candidate.tagName;

  if (
    !Predicate.isString(id) ||
    id.length === 0 ||
    !Predicate.isString(threadId) ||
    threadId.length === 0 ||
    !Predicate.isString(pickedAt) ||
    pickedAt.length === 0 ||
    !Predicate.isString(pageUrl) ||
    pageUrl.length === 0 ||
    !Predicate.isString(tagName) ||
    tagName.length === 0
  ) {
    return null;
  }

  const sourceCandidate = candidate.source;
  let source: PersistedElementContextDraft["source"] = null;

  if (Predicate.isObjectOrArray(sourceCandidate)) {
    const sourceRecord = sourceCandidate;
    source = {
      functionName: Predicate.isString(sourceRecord.functionName)
        ? sourceRecord.functionName
        : null,
      fileName: Predicate.isString(sourceRecord.fileName) ? sourceRecord.fileName : null,
      lineNumber:
        Predicate.isNumber(sourceRecord.lineNumber) && Number.isFinite(sourceRecord.lineNumber)
          ? sourceRecord.lineNumber
          : null,
      columnNumber:
        Predicate.isNumber(sourceRecord.columnNumber) && Number.isFinite(sourceRecord.columnNumber)
          ? sourceRecord.columnNumber
          : null,
    };
  }

  return {
    id,
    threadId: ThreadId.make(threadId),
    pickedAt,
    pageUrl,
    pageTitle: Predicate.isString(candidate.pageTitle) ? candidate.pageTitle : null,
    tagName,
    selector: Predicate.isString(candidate.selector) ? candidate.selector : null,
    htmlPreview: Predicate.isString(candidate.htmlPreview) ? candidate.htmlPreview : "",
    componentName: Predicate.isString(candidate.componentName) ? candidate.componentName : null,
    source,
    styles: Predicate.isString(candidate.styles) ? candidate.styles : "",
  };
}

function normalizePersistedTerminalContextDraft(
  value: StoredTerminalContext | null,
): PersistedTerminalContextDraft | null {
  if (!Predicate.isObjectOrArray(value)) {
    return null;
  }

  const candidate = value;
  const id = candidate.id;
  const threadId = candidate.threadId;
  const createdAt = candidate.createdAt;
  const lineStart = candidate.lineStart;
  const lineEnd = candidate.lineEnd;

  if (
    !Predicate.isString(id) ||
    id.length === 0 ||
    !Predicate.isString(threadId) ||
    threadId.length === 0 ||
    !Predicate.isString(createdAt) ||
    createdAt.length === 0 ||
    !Predicate.isNumber(lineStart) ||
    !Number.isFinite(lineStart) ||
    !Predicate.isNumber(lineEnd) ||
    !Number.isFinite(lineEnd)
  ) {
    return null;
  }

  const terminalId = Predicate.isString(candidate.terminalId) ? candidate.terminalId.trim() : "";

  const terminalLabel = Predicate.isString(candidate.terminalLabel)
    ? candidate.terminalLabel.trim()
    : "";

  if (terminalId.length === 0 || terminalLabel.length === 0) {
    return null;
  }

  const normalizedLineStart = Math.max(1, Math.floor(lineStart));
  const normalizedLineEnd = Math.max(normalizedLineStart, Math.floor(lineEnd));

  return {
    id,
    threadId: ThreadId.make(threadId),
    createdAt,
    terminalId,
    terminalLabel,
    lineStart: normalizedLineStart,
    lineEnd: normalizedLineEnd,
  };
}

export function normalizePersistedDraftThreads(
  rawDraftThreadsByThreadId: StoredComposerMigration["draftThreadsByThreadKey"],
  rawProjectDraftThreadIdByProjectKey: StoredComposerMigration["logicalProjectDraftThreadKeyByLogicalProjectKey"],
): Pick<
  PersistedComposerDraftStoreState,
  "draftThreadsByThreadKey" | "logicalProjectDraftThreadKeyByLogicalProjectKey"
> {
  const draftThreadsByThreadKey: Record<string, PersistedDraftThreadState> = {};
  const environmentIdByThreadId = new Map<ThreadId, EnvironmentId>();

  if (
    rawProjectDraftThreadIdByProjectKey &&
    (rawProjectDraftThreadIdByProjectKey === null ||
      Predicate.isObjectOrArray(rawProjectDraftThreadIdByProjectKey))
  ) {
    for (const [projectKey, threadId] of Object.entries(rawProjectDraftThreadIdByProjectKey)) {
      if (!Predicate.isString(threadId) || threadId.length === 0) {
        continue;
      }

      const projectRef = parseScopedProjectKey(projectKey);

      if (!projectRef) {
        continue;
      }

      const parsedThreadRef = parseScopedThreadKey(threadId);

      if (parsedThreadRef) {
        environmentIdByThreadId.set(parsedThreadRef.threadId, parsedThreadRef.environmentId);
        continue;
      }

      environmentIdByThreadId.set(ThreadId.make(threadId), projectRef.environmentId);
    }
  }

  if (Predicate.isObjectOrArray(rawDraftThreadsByThreadId)) {
    for (const [threadKeyOrId, rawDraftThread] of Object.entries(rawDraftThreadsByThreadId)) {
      if (!Predicate.isString(threadKeyOrId) || threadKeyOrId.length === 0) {
        continue;
      }

      if (!Predicate.isObjectOrArray(rawDraftThread)) {
        continue;
      }

      const candidateDraftThread = rawDraftThread;
      const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
      const threadKey = normalizeLegacyComposerStorageKey(threadKeyOrId);

      const threadId =
        parsedThreadRef?.threadId ??
        (Predicate.isString(candidateDraftThread.threadId) &&
        candidateDraftThread.threadId.length > 0
          ? ThreadId.make(candidateDraftThread.threadId)
          : ThreadId.make(threadKeyOrId));

      const environmentId =
        parsedThreadRef?.environmentId ??
        (Predicate.isString(candidateDraftThread.environmentId) &&
        candidateDraftThread.environmentId.length > 0
          ? EnvironmentId.make(candidateDraftThread.environmentId)
          : environmentIdByThreadId.get(ThreadId.make(threadKeyOrId)));

      const projectId = candidateDraftThread.projectId;
      const createdAt = candidateDraftThread.createdAt;
      const branch = candidateDraftThread.branch;
      const worktreePath = candidateDraftThread.worktreePath;
      const startFromOrigin = candidateDraftThread.startFromOrigin === true;
      const normalizedWorktreePath = Predicate.isString(worktreePath) ? worktreePath : null;
      const promotedToCandidate = candidateDraftThread.promotedTo;

      const promotedToRecord = Predicate.isObjectOrArray(promotedToCandidate)
        ? promotedToCandidate
        : null;

      const promotedTo =
        promotedToRecord &&
        Predicate.isString(promotedToRecord.environmentId) &&
        promotedToRecord.environmentId.length > 0 &&
        Predicate.isString(promotedToRecord.threadId) &&
        promotedToRecord.threadId.length > 0
          ? scopeThreadRef(
              EnvironmentId.make(promotedToRecord.environmentId),
              ThreadId.make(promotedToRecord.threadId),
            )
          : null;

      if (!Predicate.isString(projectId) || projectId.length === 0 || environmentId === undefined) {
        continue;
      }

      const normalizedEnvironmentId = EnvironmentId.make(environmentId);
      draftThreadsByThreadKey[threadKey] = {
        threadId,
        environmentId: normalizedEnvironmentId,
        projectId: ProjectId.make(projectId),
        logicalProjectKey:
          Predicate.isString(candidateDraftThread.logicalProjectKey) &&
          candidateDraftThread.logicalProjectKey.length > 0
            ? candidateDraftThread.logicalProjectKey
            : parsedThreadRef
              ? projectDraftKey(scopeProjectRef(normalizedEnvironmentId, ProjectId.make(projectId)))
              : threadKeyOrId,
        createdAt:
          Predicate.isString(createdAt) && createdAt.length > 0
            ? createdAt
            : new Date().toISOString(),
        runtimeMode: isRuntimeMode(candidateDraftThread.runtimeMode)
          ? candidateDraftThread.runtimeMode
          : DEFAULT_LOCAL_EXECUTION_MODE,
        interactionMode:
          candidateDraftThread.interactionMode === "plan" ||
          candidateDraftThread.interactionMode === "default"
            ? candidateDraftThread.interactionMode
            : DEFAULT_INTERACTION_MODE,
        branch: Predicate.isString(branch) ? branch : null,
        worktreePath: normalizedWorktreePath,
        envMode: normalizeDraftThreadEnvMode(candidateDraftThread.envMode, normalizedWorktreePath),
        startFromOrigin,
        promotedTo,
      };
    }
  }

  const logicalProjectDraftThreadKeyByLogicalProjectKey: Record<string, string> = {};

  if (
    rawProjectDraftThreadIdByProjectKey &&
    (rawProjectDraftThreadIdByProjectKey === null ||
      Predicate.isObjectOrArray(rawProjectDraftThreadIdByProjectKey))
  ) {
    for (const [logicalProjectKey, threadKeyOrId] of Object.entries(
      rawProjectDraftThreadIdByProjectKey,
    )) {
      if (!Predicate.isString(threadKeyOrId) || threadKeyOrId.length === 0) {
        continue;
      }

      const projectRef = parseScopedProjectKey(logicalProjectKey);
      const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);
      const threadKey = normalizeLegacyComposerStorageKey(threadKeyOrId);
      logicalProjectDraftThreadKeyByLogicalProjectKey[logicalProjectKey] = threadKey;

      if (parsedThreadRef) {
        environmentIdByThreadId.set(parsedThreadRef.threadId, parsedThreadRef.environmentId);
      }

      if (!projectRef) {
        const existingDraftThread = draftThreadsByThreadKey[threadKey];

        if (existingDraftThread && !existingDraftThread.logicalProjectKey) {
          draftThreadsByThreadKey[threadKey] = {
            ...existingDraftThread,
            logicalProjectKey,
          };
        }

        continue;
      }

      if (!draftThreadsByThreadKey[threadKey]) {
        draftThreadsByThreadKey[threadKey] = {
          threadId: parsedThreadRef?.threadId ?? ThreadId.make(threadKey),
          environmentId: projectRef.environmentId,
          projectId: projectRef.projectId,
          logicalProjectKey,
          createdAt: new Date().toISOString(),
          runtimeMode: DEFAULT_LOCAL_EXECUTION_MODE,
          interactionMode: DEFAULT_INTERACTION_MODE,
          branch: null,
          worktreePath: null,
          envMode: "local",
          startFromOrigin: false,
          promotedTo: null,
        };
      } else if (
        draftThreadsByThreadKey[threadKey]?.projectId !== projectRef.projectId ||
        draftThreadsByThreadKey[threadKey]?.environmentId !== projectRef.environmentId
      ) {
        draftThreadsByThreadKey[threadKey] = {
          ...draftThreadsByThreadKey[threadKey]!,
          threadId: draftThreadsByThreadKey[threadKey]!.threadId,
          environmentId: projectRef.environmentId,
          projectId: projectRef.projectId,
          logicalProjectKey,
        };
      }
    }
  }

  return { draftThreadsByThreadKey, logicalProjectDraftThreadKeyByLogicalProjectKey };
}

export function normalizePersistedDraftsByThreadId(
  rawDraftMap: StoredComposerMigration["draftsByThreadKey"],
  draftThreadsByThreadKey: PersistedComposerDraftStoreState["draftThreadsByThreadKey"],
): PersistedComposerDraftStoreState["draftsByThreadKey"] {
  if (!Predicate.isObjectOrArray(rawDraftMap)) {
    return {};
  }

  const environmentIdByThreadId = new Map<ThreadId, EnvironmentId>();

  for (const [threadKey, draftThread] of Object.entries(draftThreadsByThreadKey)) {
    const parsedThreadRef = composerThreadRefFromKey(threadKey);

    if (!parsedThreadRef) {
      continue;
    }

    environmentIdByThreadId.set(
      parsedThreadRef.threadId,
      EnvironmentId.make(draftThread.environmentId),
    );
  }

  const nextDraftsByThreadKey: DeepMutable<PersistedComposerDraftStoreState["draftsByThreadKey"]> =
    {};

  for (const [threadKeyOrId, draftValue] of Object.entries(rawDraftMap)) {
    if (!Predicate.isString(threadKeyOrId) || threadKeyOrId.length === 0) {
      continue;
    }

    if (!Predicate.isObjectOrArray(draftValue)) {
      continue;
    }

    const draftCandidate = draftValue;
    const promptCandidate = Predicate.isString(draftCandidate.prompt) ? draftCandidate.prompt : "";

    const attachments = Array.isArray(draftCandidate.attachments)
      ? draftCandidate.attachments.flatMap((entry) => {
          const normalized = normalizePersistedAttachment(entry);

          return normalized ? [normalized] : [];
        })
      : [];

    const terminalContexts = Array.isArray(draftCandidate.terminalContexts)
      ? draftCandidate.terminalContexts.flatMap((entry) => {
          const normalized = normalizePersistedTerminalContextDraft(entry);

          return normalized ? [normalized] : [];
        })
      : [];

    const elementContexts = Array.isArray(draftCandidate.elementContexts)
      ? draftCandidate.elementContexts.flatMap((entry) => {
          const normalized = normalizePersistedElementContextDraft(entry);

          return normalized ? [normalized] : [];
        })
      : [];

    const runtimeMode = isRuntimeMode(draftCandidate.runtimeMode)
      ? draftCandidate.runtimeMode
      : null;

    const interactionMode =
      draftCandidate.interactionMode === "plan" || draftCandidate.interactionMode === "default"
        ? draftCandidate.interactionMode
        : null;

    const prompt = ensureInlineTerminalContextPlaceholders(
      promptCandidate,
      terminalContexts.length,
    );

    // If the draft already has the v3 shape, use it directly
    const legacyDraftCandidate = draftValue;
    let modelSelectionByProvider: Partial<Record<ProviderInstanceId, ModelSelection>> = {};
    let activeProvider: ProviderInstanceId | null = null;

    if (
      draftCandidate.modelSelectionByProvider &&
      (draftCandidate.modelSelectionByProvider === null ||
        Predicate.isObjectOrArray(draftCandidate.modelSelectionByProvider))
    ) {
      // v3 format
      modelSelectionByProvider = draftCandidate.modelSelectionByProvider;
      activeProvider = normalizeProviderInstanceId(draftCandidate.activeProvider);
    } else {
      // v2 or legacy format: migrate
      const normalizedModelOptions =
        normalizeProviderModelOptions(
          legacyDraftCandidate.modelOptions,
          undefined,
          legacyDraftCandidate,
        ) ?? null;

      const normalizedModelSelection = normalizeModelSelection(
        legacyDraftCandidate.modelSelection,
        {
          provider: legacyDraftCandidate.provider,
          model: legacyDraftCandidate.model,
          modelOptions: normalizedModelOptions ?? legacyDraftCandidate.modelOptions,
          legacyCodex: legacyDraftCandidate,
        },
      );

      const mergedModelOptions = legacyMergeModelSelectionIntoProviderModelOptions(
        normalizedModelSelection,
        normalizedModelOptions,
      );

      const modelSelection = legacySyncModelSelectionOptions(
        normalizedModelSelection,
        mergedModelOptions,
      );

      modelSelectionByProvider = legacyToModelSelectionByProvider(
        modelSelection,
        mergedModelOptions,
      );
      activeProvider = modelSelection?.instanceId ?? null;
    }

    const hasModelData =
      Object.keys(modelSelectionByProvider).length > 0 || activeProvider !== null;

    if (
      promptCandidate.length === 0 &&
      attachments.length === 0 &&
      terminalContexts.length === 0 &&
      elementContexts.length === 0 &&
      !hasModelData &&
      !runtimeMode &&
      !interactionMode
    ) {
      continue;
    }

    const parsedThreadRef = parseScopedThreadKey(threadKeyOrId);

    const normalizedThreadKey =
      parsedThreadRef !== null
        ? normalizeLegacyComposerStorageKey(threadKeyOrId)
        : draftThreadsByThreadKey[threadKeyOrId] !== undefined
          ? threadKeyOrId
          : (() => {
              const environmentId = environmentIdByThreadId.get(ThreadId.make(threadKeyOrId));

              return environmentId
                ? normalizeLegacyComposerStorageKey(threadKeyOrId, { environmentId })
                : threadKeyOrId;
            })();

    nextDraftsByThreadKey[normalizedThreadKey] = {
      prompt,
      attachments,
      ...(terminalContexts.length > 0 ? { terminalContexts } : {}),
      ...(elementContexts.length > 0 ? { elementContexts } : {}),
      ...(hasModelData
        ? {
            modelSelectionByProvider: compactModelSelectionByProvider(modelSelectionByProvider),
            activeProvider,
          }
        : {}),
      ...(runtimeMode ? { runtimeMode } : {}),
      ...(interactionMode ? { interactionMode } : {}),
    };
  }

  return nextDraftsByThreadKey;
}