Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

11.2 KB
Raw Blame
import { matchSupportedLocale, type SupportedLocale } from "./i18n/locales";

export const AI_ACTIONS = [
  "summarize",
  "extract-key-points",
  "extract-todos",
  "rewrite-proofread",
  "translate",
  "improve-writing",
  "fix-spelling-grammar",
  "make-shorter",
  "make-longer",
  "simplify-language",
  "change-tone",
  "continue-writing",
  "custom",
] as const;

export type AiAction = (typeof AI_ACTIONS)[number];

export const AI_TONES = ["professional", "friendly", "casual", "direct"] as const;
export type AiTone = (typeof AI_TONES)[number];

export const AI_TARGET_LANGUAGES = ["en", "zh-CN", "zh-TW", "ja", "ko", "es", "fr", "de", "pt", "pl"] as const;
export type AiTargetLanguage = (typeof AI_TARGET_LANGUAGES)[number];

export const AI_ATTACHMENT_MEDIA_TYPES = [
  "image/jpeg",
  "image/png",
  "image/webp",
  "image/gif",
  "application/pdf",
  "application/json",
  "text/plain",
  "text/markdown",
  "text/csv",
] as const;
export type AiAttachmentMediaType = (typeof AI_ATTACHMENT_MEDIA_TYPES)[number];
export const MAX_AI_ATTACHMENTS = 4;
export const MAX_AI_ATTACHMENT_BYTES = 4 * 1024 * 1024;
export const MAX_AI_TEXT_ATTACHMENT_BYTES = 256 * 1024;
export const MAX_AI_ATTACHMENTS_TOTAL_BYTES = 8 * 1024 * 1024;

export const getBase64DecodedByteLength = (data: string) => {
  if (!data || data.length % 4 !== 0 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data)) {
    return null;
  }
  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
  return (data.length / 4) * 3 - padding;
};

export const isAiTextAttachment = (mediaType: AiAttachmentMediaType) =>
  mediaType.startsWith("text/") || mediaType === "application/json";

export const AI_PROMPT_PARAMETER_KINDS = ["none", "target-language", "tone"] as const;
export type AiPromptParameterKind = (typeof AI_PROMPT_PARAMETER_KINDS)[number];

export const AI_PROMPT_RESULT_MODES = ["append", "replace", "both"] as const;
export type AiPromptResultMode = (typeof AI_PROMPT_RESULT_MODES)[number];

export const AI_SELECTED_TEXT_ACTIONS: readonly AiAction[] = [
  "summarize",
  "translate",
  "improve-writing",
  "make-shorter",
  "extract-todos",
  "continue-writing",
  "custom",
];

export const AI_WHOLE_NOTE_ACTIONS: readonly AiAction[] = [
  "summarize",
  "translate",
  "improve-writing",
  "make-shorter",
  "extract-todos",
  "continue-writing",
  "custom",
];

const NON_REPLACEABLE_AI_ACTIONS: readonly AiAction[] = [
  "summarize",
  "extract-key-points",
  "extract-todos",
  "continue-writing",
];

export const getDefaultAiAction = (hasSelection: boolean): AiAction =>
  hasSelection ? "improve-writing" : "custom";

/** Last processing method is restored only for a text selection. Whole-note opens stay on custom. */
export const storedPreferenceForAiAssistantOpen = (
  hasSelection: boolean,
  preference: AiAssistantLastActionPreference | null | undefined,
): AiAssistantLastActionPreference | null => (hasSelection ? preference ?? null : null);

export const resolveAiAssistantOpenAction = ({
  hasSelection,
  preference,
  prompts,
}: {
  hasSelection: boolean;
  preference: AiAssistantLastActionPreference | null | undefined;
  prompts: readonly AiAssistantPromptOption[];
}) => resolveAiAssistantLastAction({
  fallbackAction: getDefaultAiAction(hasSelection),
  preference: storedPreferenceForAiAssistantOpen(hasSelection, preference),
  prompts,
});

const DEFAULT_AI_TARGET_LANGUAGE_BY_UI_LOCALE: Record<SupportedLocale, AiTargetLanguage> = {
  "zh-CN": "en",
  "en-US": "zh-CN",
  ja: "ja",
  pl: "en",
  ru: "en",
};

export const getDefaultAiTargetLanguage = (locale: string | undefined): AiTargetLanguage => {
  const uiLocale = matchSupportedLocale(locale);
  return uiLocale ? DEFAULT_AI_TARGET_LANGUAGE_BY_UI_LOCALE[uiLocale] : "zh-CN";
};

export const AI_ASSISTANT_LAST_ACTION_STORAGE_KEY = "edgeever.aiAssistant.lastAction";

export type AiPromptSeedAction = Exclude<AiAction, "custom">;

export type AiAssistantLastActionScope = "selected" | "wholeNote";

export type AiAssistantLastActionPreference = {
  action: AiAction;
  promptId: string | null;
  seedKey: AiPromptSeedAction | null;
  targetLanguage?: AiTargetLanguage;
  tone?: AiTone;
};

export type AiAssistantLastActionStore = {
  selected?: AiAssistantLastActionPreference;
  wholeNote?: AiAssistantLastActionPreference;
};

export const getAiAssistantLastActionScope = (hasSelection: boolean): AiAssistantLastActionScope =>
  hasSelection ? "selected" : "wholeNote";

export type AiAssistantPromptOption = {
  id: string;
  action: AiAction;
  seedKey?: AiPromptSeedAction | null;
};

const isAiAction = (value: unknown): value is AiAction =>
  typeof value === "string" && (AI_ACTIONS as readonly string[]).includes(value);

const isAiPromptSeedAction = (value: unknown): value is AiPromptSeedAction =>
  isAiAction(value) && value !== "custom";

const isAiTargetLanguage = (value: unknown): value is AiTargetLanguage =>
  typeof value === "string" && (AI_TARGET_LANGUAGES as readonly string[]).includes(value);

const isAiTone = (value: unknown): value is AiTone =>
  typeof value === "string" && (AI_TONES as readonly string[]).includes(value);

const getLocalStorage = (): Storage | null => {
  try {
    return (globalThis as { localStorage?: Storage }).localStorage ?? null;
  } catch {
    return null;
  }
};

const parseAiAssistantLastActionPreferenceObject = (
  value: unknown,
): AiAssistantLastActionPreference | null => {
  if (!value || typeof value !== "object") return null;
  const parsed = value as Record<string, unknown>;
  if (!isAiAction(parsed.action)) return null;
  return {
    action: parsed.action,
    promptId: typeof parsed.promptId === "string" ? parsed.promptId : null,
    seedKey: isAiPromptSeedAction(parsed.seedKey) ? parsed.seedKey : null,
    ...(isAiTargetLanguage(parsed.targetLanguage) ? { targetLanguage: parsed.targetLanguage } : {}),
    ...(isAiTone(parsed.tone) ? { tone: parsed.tone } : {}),
  };
};

export const parseAiAssistantLastActionPreference = (
  raw: string | null | undefined,
): AiAssistantLastActionPreference | null => {
  if (!raw) return null;
  try {
    return parseAiAssistantLastActionPreferenceObject(JSON.parse(raw));
  } catch {
    return null;
  }
};

export const parseAiAssistantLastActionStore = (
  raw: string | null | undefined,
): AiAssistantLastActionStore => {
  if (!raw) return {};
  try {
    const parsed = JSON.parse(raw) as Record<string, unknown>;
    const legacy = parseAiAssistantLastActionPreferenceObject(parsed);
    if (legacy) return { wholeNote: legacy };
    return {
      ...(parseAiAssistantLastActionPreferenceObject(parsed.selected)
        ? { selected: parseAiAssistantLastActionPreferenceObject(parsed.selected)! }
        : {}),
      ...(parseAiAssistantLastActionPreferenceObject(parsed.wholeNote)
        ? { wholeNote: parseAiAssistantLastActionPreferenceObject(parsed.wholeNote)! }
        : {}),
    };
  } catch {
    return {};
  }
};

export const serializeAiAssistantLastActionPreference = (
  preference: AiAssistantLastActionPreference,
) => JSON.stringify({
  action: preference.action,
  promptId: preference.promptId,
  seedKey: preference.seedKey,
  ...(preference.targetLanguage ? { targetLanguage: preference.targetLanguage } : {}),
  ...(preference.tone ? { tone: preference.tone } : {}),
});

export const serializeAiAssistantLastActionStore = (store: AiAssistantLastActionStore) =>
  JSON.stringify({
    ...(store.selected ? { selected: JSON.parse(serializeAiAssistantLastActionPreference(store.selected)) } : {}),
    ...(store.wholeNote ? { wholeNote: JSON.parse(serializeAiAssistantLastActionPreference(store.wholeNote)) } : {}),
  });

export const buildAiAssistantLastActionPreference = ({
  action,
  promptId,
  seedKey,
  targetLanguage,
  tone,
}: {
  action: AiAction;
  promptId?: string | null;
  seedKey?: AiPromptSeedAction | null;
  targetLanguage?: AiTargetLanguage;
  tone?: AiTone;
}): AiAssistantLastActionPreference => ({
  action,
  promptId: promptId ?? null,
  seedKey: seedKey ?? null,
  ...(targetLanguage ? { targetLanguage } : {}),
  ...(tone ? { tone } : {}),
});

export const resolveAiAssistantLastAction = ({
  fallbackAction,
  preference,
  prompts,
}: {
  fallbackAction: AiAction;
  preference: AiAssistantLastActionPreference | null;
  prompts: readonly AiAssistantPromptOption[];
}): {
  action: AiAction;
  selectedPromptId: string | null;
  targetLanguage?: AiTargetLanguage;
  tone?: AiTone;
} => {
  const extras = {
    ...(preference?.targetLanguage ? { targetLanguage: preference.targetLanguage } : {}),
    ...(preference?.tone ? { tone: preference.tone } : {}),
  };

  if (preference) {
    if (preference.promptId) {
      const byId = prompts.find((prompt) => prompt.id === preference.promptId);
      if (byId) return { action: byId.action, selectedPromptId: byId.id, ...extras };
    }
    if (preference.seedKey) {
      const bySeed = prompts.find((prompt) => prompt.seedKey === preference.seedKey);
      if (bySeed) return { action: bySeed.action, selectedPromptId: bySeed.id, ...extras };
    }
    if (preference.action === "custom" || prompts.length === 0) {
      return { action: preference.action, selectedPromptId: null, ...extras };
    }
  }

  if (fallbackAction === "custom") {
    return { action: "custom", selectedPromptId: null };
  }
  const fallbackPrompt = prompts.find((prompt) => prompt.seedKey === fallbackAction) ?? prompts[0] ?? null;
  if (fallbackPrompt) {
    return { action: fallbackPrompt.action, selectedPromptId: fallbackPrompt.id };
  }
  return { action: fallbackAction, selectedPromptId: null };
};

export const readStoredAiAssistantLastActionPreference = (
  scope: AiAssistantLastActionScope,
): AiAssistantLastActionPreference | null =>
  parseAiAssistantLastActionStore(getLocalStorage()?.getItem(AI_ASSISTANT_LAST_ACTION_STORAGE_KEY))[scope] ?? null;

export const writeStoredAiAssistantLastActionPreference = (
  scope: AiAssistantLastActionScope,
  preference: AiAssistantLastActionPreference,
) => {
  try {
    const storage = getLocalStorage();
    const current = parseAiAssistantLastActionStore(storage?.getItem(AI_ASSISTANT_LAST_ACTION_STORAGE_KEY));
    storage?.setItem(
      AI_ASSISTANT_LAST_ACTION_STORAGE_KEY,
      serializeAiAssistantLastActionStore({ ...current, [scope]: preference }),
    );
  } catch {
    // Private mode / blocked storage — keep the in-session selection only.
  }
};

export const canReplaceAiSource = (action: AiAction) => !NON_REPLACEABLE_AI_ACTIONS.includes(action);

/** Actions that need an extra picker (language / tone) in the assistant UI. */
export const AI_ACTIONS_WITH_EXTRA_PARAMS: readonly AiAction[] = ["translate", "change-tone"];

export const actionNeedsTargetLanguage = (action: AiAction | string | null | undefined) =>
  action === "translate";

export const actionNeedsTone = (action: AiAction | string | null | undefined) =>
  action === "change-tone";

export const promptNeedsTargetLanguage = (parameterKind: AiPromptParameterKind) =>
  parameterKind === "target-language";

export const promptNeedsTone = (parameterKind: AiPromptParameterKind) =>
  parameterKind === "tone";

export const promptAllowsAppend = (resultMode: AiPromptResultMode) =>
  resultMode === "append" || resultMode === "both";

export const promptAllowsReplace = (resultMode: AiPromptResultMode) =>
  resultMode === "replace" || resultMode === "both";