nolo-cli 0.1.23 → 0.1.29

package/chat/web/messageInputAgentUi.ts

@@ -0,0 +1,189 @@
+import type { Agent } from "../../app/types";
+import { getPublicImageAgentMode } from "../../ai/agent/utils/publicImageAgentMode";
+import { resolveAgentImageInputSupport } from "../../ai/llm/agentCapabilities";
+import { getApproxPricePerImage } from "../../ai/llm/imagePricing";
+import { getModelConfig, getProviderByModelName, type Provider } from "../../ai/llm/providers";
+import type { Model } from "../../ai/llm/types";
+
+export interface FavoriteAgentSummary {
+  agentKey: string;
+  name: string;
+}
+
+export interface FavoriteAgentSource {
+  agentKey: string;
+  agent: Pick<Agent, "name"> | null | undefined;
+}
+
+export interface ImageUiConfig {
+  showControls: boolean;
+  supportsImageConfig: boolean;
+  supportedAspectRatios: string[];
+  supportedImageSizes: ("1K" | "2K" | "4K")[];
+  pricePerImage?: number;
+  pricingModel?: Pick<
+    Model,
+    "pricePerImage" | "imageTokenPricePerMillion" | "imageOutputTokenEstimateBySize"
+  >;
+}
+
+export function normalizeFavoriteAgentSummary(
+  agentKey: string,
+  agent: Pick<Agent, "name"> | null | undefined
+): FavoriteAgentSummary {
+  const rawName = typeof agent?.name === "string" ? agent.name.trim() : "";
+  return {
+    agentKey,
+    name: rawName || agentKey,
+  };
+}
+
+export function resolveFavoriteAgentSummaries(
+  sources: FavoriteAgentSource[]
+): FavoriteAgentSummary[] {
+  return sources.flatMap((source) =>
+    source.agent
+      ? [normalizeFavoriteAgentSummary(source.agentKey, source.agent)]
+      : []
+  );
+}
+
+export function filterFavoriteAgentsByQuery(input: {
+  favoriteAgents: FavoriteAgentSummary[];
+  isAgentMentionActive: boolean;
+  query: string;
+}): FavoriteAgentSummary[] {
+  const { favoriteAgents, isAgentMentionActive, query } = input;
+  if (!isAgentMentionActive || favoriteAgents.length === 0) return [];
+
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) return favoriteAgents;
+
+  return favoriteAgents.filter((agent) => {
+    const name = agent.name.toLowerCase();
+    const key = agent.agentKey.toLowerCase();
+    return name.includes(normalizedQuery) || key.includes(normalizedQuery);
+  });
+}
+
+function resolveAgentModelIdentity(agent: Partial<Agent>) {
+  let providerKey = (agent.provider || "").toLowerCase();
+  let modelName = agent.model ?? "";
+
+  if (modelName.includes("/")) {
+    const slash = modelName.indexOf("/");
+    if (!providerKey) providerKey = modelName.slice(0, slash);
+    modelName = modelName.slice(slash + 1);
+  }
+
+  let modelConfig: Model | null = null;
+
+  try {
+    modelConfig = getModelConfig(providerKey as Provider, modelName);
+  } catch {
+    try {
+      const detected = getProviderByModelName(modelName);
+      if (detected) {
+        modelConfig = getModelConfig(detected, modelName);
+        providerKey = detected;
+      }
+    } catch {
+      modelConfig = null;
+    }
+  }
+
+  return { providerKey, modelConfig };
+}
+
+export function resolveMessageInputAgentUi(input: {
+  agent: Partial<Agent>;
+  userId: string | null;
+}): {
+  switchModelQueryUserId: string | null;
+  currentModelCapabilities: {
+    hasImageOutput: boolean;
+    hasVision: boolean;
+    provider: string;
+  } | null;
+  imageUiConfig: ImageUiConfig | null;
+} {
+  const { agent, userId } = input;
+  const switchModelQueryUserId =
+    (typeof userId === "string" && userId.trim()) ||
+    (typeof agent.userId === "string" && agent.userId.trim()) ||
+    null;
+
+  const { providerKey, modelConfig } = resolveAgentModelIdentity(agent);
+  const hasVision = resolveAgentImageInputSupport(agent as any);
+
+  if (!modelConfig) {
+    return {
+      switchModelQueryUserId,
+      currentModelCapabilities: {
+        hasImageOutput: false,
+        hasVision,
+        provider: providerKey || "custom",
+      },
+      imageUiConfig: null,
+    };
+  }
+
+  const imageMode = getPublicImageAgentMode(agent as any);
+  const hasImageOutput =
+    !!(modelConfig.hasImageOutput ?? (modelConfig as any).supportsImageOutput) ||
+    imageMode === "continuous";
+
+  const currentModelCapabilities = {
+    hasImageOutput,
+    hasVision,
+    provider: providerKey,
+  };
+
+  if (!hasImageOutput) {
+    return {
+      switchModelQueryUserId,
+      currentModelCapabilities,
+      imageUiConfig: {
+        showControls: false,
+        supportsImageConfig: false,
+        supportedAspectRatios: [],
+        supportedImageSizes: [],
+        pricingModel: undefined,
+      },
+    };
+  }
+
+  const supportsImageConfig =
+    !!modelConfig.supportsImageConfig || imageMode === "continuous";
+
+  const supportedAspectRatios =
+    modelConfig.supportedAspectRatios ??
+    (imageMode === "continuous"
+      ? ["1:1", "4:3", "16:9", "9:16"]
+      : ["1:1", "4:3", "16:9", "9:16", "21:9"]);
+
+  const supportedImageSizes =
+    (modelConfig.supportedImageSizes as ("1K" | "2K" | "4K")[]) ??
+    (imageMode === "continuous" ? ["1K", "2K"] : ["1K", "2K", "4K"]);
+
+  const pricingModel = {
+    pricePerImage: modelConfig.pricePerImage,
+    imageTokenPricePerMillion: modelConfig.imageTokenPricePerMillion,
+    imageOutputTokenEstimateBySize:
+      modelConfig.imageOutputTokenEstimateBySize,
+  };
+
+  return {
+    switchModelQueryUserId,
+    currentModelCapabilities,
+    imageUiConfig: {
+      showControls: true,
+      supportsImageConfig,
+      supportedAspectRatios,
+      supportedImageSizes,
+      pricePerImage:
+        getApproxPricePerImage(pricingModel, undefined) ?? undefined,
+      pricingModel,
+    },
+  };
+}

package/chat/web/messageInputKeyBehavior.ts

@@ -0,0 +1,53 @@
+export type MessageInputKeyAction =
+  | "none"
+  | "mention-next"
+  | "mention-prev"
+  | "mention-select"
+  | "mention-close"
+  | "send";
+
+export const decideMessageInputKeyAction = ({
+  key,
+  shiftKey,
+  isMobile,
+  hasMentionMenu,
+  shouldDeferEnterForIme,
+}: {
+  key: string;
+  shiftKey: boolean;
+  isMobile: boolean;
+  hasMentionMenu: boolean;
+  shouldDeferEnterForIme: boolean;
+}): MessageInputKeyAction => {
+  if (hasMentionMenu) {
+    if (key === "ArrowDown") {
+      return "mention-next";
+    }
+
+    if (key === "ArrowUp") {
+      return "mention-prev";
+    }
+
+    if (key === "Enter") {
+      if (shouldDeferEnterForIme) {
+        return "none";
+      }
+      return "mention-select";
+    }
+
+    if (key === "Tab") {
+      return "mention-select";
+    }
+
+    if (key === "Escape") {
+      return "mention-close";
+    }
+  }
+
+  if (!isMobile && key === "Enter" && !shiftKey && !shouldDeferEnterForIme) {
+    return "send";
+  }
+
+  return "none";
+};
+

package/chat/web/messageInputMention.ts

@@ -0,0 +1,102 @@
+import type { FavoriteAgentSummary } from "./messageInputAgentUi";
+
+export type MentionKind = "agent";
+
+export interface MentionState {
+  active: boolean;
+  kind: MentionKind | null;
+  query: string;
+  startIndex: number;
+}
+
+export const createInactiveMentionState = (): MentionState => ({
+  active: false,
+  kind: null,
+  query: "",
+  startIndex: -1,
+});
+
+export const resolveAgentMentionState = (
+  value: string,
+  cursorIndex: number
+): MentionState => {
+  const textValue = value ?? "";
+  const cursor = Math.min(Math.max(cursorIndex, 0), textValue.length);
+
+  for (let i = cursor - 1; i >= 0; i -= 1) {
+    const ch = textValue[i];
+
+    if (ch === "@") {
+      if (i > 0 && /\w/.test(textValue[i - 1])) {
+        break;
+      }
+
+      const query = textValue.slice(i + 1, cursor);
+      if (/\s/.test(query)) {
+        break;
+      }
+
+      return {
+        active: true,
+        kind: "agent",
+        query,
+        startIndex: i,
+      };
+    }
+
+    if (/\s/.test(ch)) {
+      break;
+    }
+  }
+
+  return createInactiveMentionState();
+};
+
+export const buildAgentMentionInsertion = ({
+  currentValue,
+  cursorPos,
+  mentionState,
+  agent,
+}: {
+  currentValue: string;
+  cursorPos: number;
+  mentionState: MentionState;
+  agent: FavoriteAgentSummary;
+}) => {
+  if (
+    !mentionState.active ||
+    mentionState.kind !== "agent" ||
+    mentionState.startIndex < 0
+  ) {
+    return null;
+  }
+
+  const before = currentValue.slice(0, mentionState.startIndex);
+  const after = currentValue.slice(cursorPos);
+  const safeName = agent.name || agent.agentKey;
+  const mentionText = `@${safeName} `;
+
+  return {
+    nextText: `${before}${mentionText}${after}`,
+    nextMentionState: createInactiveMentionState(),
+    nextMentionHighlightIndex: 0,
+    targetAgentKey: agent.agentKey,
+  };
+};
+
+export const moveMentionHighlightIndex = ({
+  previousIndex,
+  optionCount,
+  direction,
+}: {
+  previousIndex: number;
+  optionCount: number;
+  direction: "next" | "prev";
+}) => {
+  if (optionCount <= 0) return 0;
+  const maxIndex = optionCount - 1;
+  if (direction === "next") {
+    return previousIndex >= maxIndex ? maxIndex : previousIndex + 1;
+  }
+  return previousIndex <= 0 ? 0 : previousIndex - 1;
+};

package/chat/web/messageInputSendResolver.ts

@@ -0,0 +1,51 @@
+export type MessageInputSendDecision =
+  | { kind: "arm-fresh-dialog" }
+  | { kind: "compact-blocked" }
+  | { kind: "compact-dialog" }
+  | { kind: "noop" }
+  | { kind: "multi-image-blocked" }
+  | { kind: "queue-text"; text: string }
+  | { kind: "queue-blocked" }
+  | { kind: "send"; text: string };
+
+export function resolveMessageInputSendDecision(input: {
+  text: string;
+  imagePreviewCount: number;
+  pendingFileCount: number;
+  isSendBlocked: boolean;
+  canMultiImg: boolean;
+  isLoopRunning: boolean;
+  isSendPending: boolean;
+  isFreshDialogSlashCommand: (input: string) => boolean;
+  isCompactDialogSlashCommand: (input: string) => boolean;
+}): MessageInputSendDecision {
+  const trimmed = input.text.trim();
+
+  if (input.isFreshDialogSlashCommand(trimmed)) {
+    return { kind: "arm-fresh-dialog" };
+  }
+
+  if (input.isCompactDialogSlashCommand(trimmed)) {
+    if (input.isLoopRunning || input.isSendPending) {
+      return { kind: "compact-blocked" };
+    }
+    return { kind: "compact-dialog" };
+  }
+
+  if ((!trimmed && !input.imagePreviewCount && !input.pendingFileCount) || input.isSendBlocked) {
+    return { kind: "noop" };
+  }
+
+  if (!input.canMultiImg && input.imagePreviewCount > 1) {
+    return { kind: "multi-image-blocked" };
+  }
+
+  if (input.isLoopRunning) {
+    if (trimmed && !input.imagePreviewCount && !input.pendingFileCount) {
+      return { kind: "queue-text", text: trimmed };
+    }
+    return { kind: "queue-blocked" };
+  }
+
+  return { kind: "send", text: trimmed };
+}

package/chat/web/messageSlashCommands.ts

@@ -0,0 +1,10 @@
+export const FRESH_DIALOG_SLASH_COMMAND = "/new";
+export const COMPACT_DIALOG_SLASH_COMMAND = "/compact";
+
+export function isFreshDialogSlashCommand(input: string): boolean {
+  return input.trim() === FRESH_DIALOG_SLASH_COMMAND;
+}
+
+export function isCompactDialogSlashCommand(input: string): boolean {
+  return input.trim() === COMPACT_DIALOG_SLASH_COMMAND;
+}

package/chat/web/pdfOcrProcessor.ts

@@ -0,0 +1,131 @@
+/**
+ * pdfOcrProcessor.ts
+ *
+ * 混合模式 PDF 处理：
+ * - pdf.js 先提取每页文字
+ * - 若某页字符数 < TEXT_THRESHOLD（扫描页/图片页），才调用 OCR API
+ * - 有文字的页面继续走 pdf.js 路径，节省费用
+ */
+
+import * as pdfjsLib from "pdfjs-dist";
+
+/** 低于此字符数判定为扫描页，触发 OCR */
+const TEXT_THRESHOLD = 50;
+
+const OCR_ENDPOINT_MAP: Record<string, string> = {
+  olm_ocr: "/api/olm-ocr",
+};
+
+interface SlateNode {
+  type: string;
+  children: Array<{ text: string }>;
+}
+
+interface OcrRequestContext {
+  serverOrigin?: string;
+  accessToken?: string;
+  dialogId?: string;
+}
+
+/**
+ * 将 PDF 文件用混合方式转为 Slate 节点数组。
+ * - 有文字层的页：直接用 pdf.js 提取文字（免费）
+ * - 扫描页（字符 < 50）：渲染为图片，调用 OCR API
+ */
+export async function processPdfWithOcr(
+  file: File,
+  ocrModel: string,
+  ocrRequest: OcrRequestContext
+): Promise<SlateNode[]> {
+  const endpoint = OCR_ENDPOINT_MAP[ocrModel];
+  if (!endpoint) throw new Error(`未知 OCR 模型: ${ocrModel}`);
+  const { serverOrigin, accessToken, dialogId } = ocrRequest;
+  if (!serverOrigin || !accessToken) {
+    throw new Error("OCR 请求缺少 server 或 token");
+  }
+
+  const arrayBuffer = await file.arrayBuffer();
+  const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
+  const numPages = pdf.numPages;
+  const nodes: SlateNode[] = [];
+
+  for (let pageNum = 1; pageNum <= numPages; pageNum++) {
+    const page = await pdf.getPage(pageNum);
+
+    // 先尝试 pdf.js 提取文字
+    const textContent = await page.getTextContent();
+    const pageText = textContent.items
+      .map((item: any) => ("str" in item ? item.str : ""))
+      .join(" ")
+      .trim();
+
+    let pageNodes: SlateNode[];
+
+    if (pageText.length >= TEXT_THRESHOLD) {
+      // ── 有文字层：直接拆段落，无需 OCR ──
+      pageNodes = pageText
+        .split(/\n+/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .map((line) => ({ type: "paragraph", children: [{ text: line }] }));
+
+      if (pageNodes.length === 0) {
+        pageNodes = [{ type: "paragraph", children: [{ text: pageText }] }];
+      }
+    } else {
+      // ── 扫描页：渲染为 JPEG 图片，调用 OCR API ──
+      const viewport = page.getViewport({ scale: 2.0 });
+      const canvas = document.createElement("canvas");
+      canvas.width = viewport.width;
+      canvas.height = viewport.height;
+      const ctx = canvas.getContext("2d")!;
+      await page.render({ canvasContext: ctx, viewport }).promise;
+      const base64 = canvas.toDataURL("image/jpeg", 0.92);
+
+      const res = await fetch(`${serverOrigin}${endpoint}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({
+          imageUrl: base64,
+          prompt: "识别图片中的所有文字，保留原始格式和排版",
+          ...(dialogId ? { dialogId } : {}),
+        }),
+      });
+
+      if (!res.ok) {
+        const errText = await res.text();
+        throw new Error(`OCR 第 ${pageNum} 页失败: ${errText}`);
+      }
+
+      const data = await res.json();
+      const ocrText: string =
+        data.choices?.[0]?.message?.content || `（第 ${pageNum} 页无内容）`;
+
+      pageNodes = ocrText
+        .split("\n")
+        .map((line: string) => line.trim())
+        .filter((line: string) => line.length > 0)
+        .map((line: string) => ({ type: "paragraph", children: [{ text: line }] }));
+
+      if (pageNodes.length === 0) {
+        pageNodes = [{ type: "paragraph", children: [{ text: ocrText }] }];
+      }
+    }
+
+    nodes.push(...pageNodes);
+
+    // 页间分隔
+    if (pageNum < numPages) {
+      nodes.push({ type: "thematic-break", children: [{ text: "" }] });
+    }
+  }
+
+  if (nodes.length === 0) {
+    nodes.push({ type: "paragraph", children: [{ text: "（未识别到内容）" }] });
+  }
+
+  return nodes;
+}

package/chat/web/sidebar/allViewSearch.ts

@@ -0,0 +1,87 @@
+import type { MyContentListItem } from "../../../app/utils/myContentItems";
+export { isRoutableContentActive } from "../../../create/space/contentKeyUtils";
+import type { ShareSummary } from "../../../share/types";
+import { getShareTypeLabel } from "../../../share/types";
+
+export type FavoriteSearchRecord = {
+  type?: string;
+  title?: string;
+  name?: string;
+  fileCategory?: string | null;
+  spaceId?: string | null;
+};
+
+const normalizeSearchText = (value: unknown): string =>
+  typeof value === "string" ? value.trim().toLowerCase() : "";
+
+export const isAllViewDialogImageAttachment = (item: {
+  type?: string | null;
+  fileCategory?: string | null;
+  spaceId?: string | null;
+}): boolean => {
+  const normalizedType = normalizeSearchText(item.type);
+  const normalizedFileCategory = normalizeSearchText(item.fileCategory);
+  const hasSpace = typeof item.spaceId === "string" && item.spaceId.trim().length > 0;
+
+  return normalizedType === "file" && normalizedFileCategory === "image" && !hasSpace;
+};
+
+export const matchesAllViewSearch = (
+  searchQuery: string,
+  ...values: Array<unknown>
+): boolean => {
+  const normalizedSearchQuery = normalizeSearchText(searchQuery);
+  if (!normalizedSearchQuery) return false;
+
+  return values.some((value) =>
+    normalizeSearchText(value).includes(normalizedSearchQuery)
+  );
+};
+
+export const filterAllViewRecentItems = (
+  items: MyContentListItem[],
+  searchQuery: string
+): MyContentListItem[] => {
+  return items.filter((item) =>
+    matchesAllViewSearch(
+      searchQuery,
+      item.title,
+      item.type,
+      item.spaceName,
+      item.contentKey
+    )
+  );
+};
+
+export const filterAllViewFavoriteKeys = (
+  favoriteKeys: string[],
+  favoriteRecordsByKey: Record<string, FavoriteSearchRecord | undefined>,
+  searchQuery: string
+): string[] => {
+  return favoriteKeys.filter((favoriteKey) => {
+    const record = favoriteRecordsByKey[favoriteKey];
+    return matchesAllViewSearch(
+      searchQuery,
+      record?.title,
+      record?.name,
+      record?.type,
+      record?.spaceId,
+      favoriteKey
+    );
+  });
+};
+
+export const filterAllViewShares = (
+  shares: ShareSummary[],
+  searchQuery: string
+): ShareSummary[] => {
+  return shares.filter((share) =>
+    matchesAllViewSearch(
+      searchQuery,
+      share.title,
+      share.description,
+      share.authorName,
+      getShareTypeLabel(share.type)
+    )
+  );
+};

package/chat/web/sidebar/types.ts

@@ -0,0 +1,12 @@
+import type { SpaceContent } from "../../../app/types";
+
+export interface ChatSidebarCategoryItem {
+  id: string;
+  name: string;
+  order?: number;
+}
+
+export interface ChatSidebarGroupedData {
+  uncategorized: SpaceContent[];
+  categorized: Record<string, SpaceContent[]>;
+}