Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

15.3 KB
Raw Blame
"use client";

import { KnowledgeBaseCrumb } from "@/components/layout/instance-crumbs";
import Tooltip from "@/shared/ui/Tooltip";
import { knowledgeBaseRef } from "@/lib/knowledge-helpers";
import type { EmbeddingModelSelection } from "@/features/knowledge/model/types";

import { useState } from "react";
import { useTranslation } from "react-i18next";
import LightRagEmbeddingWarning from "./LightRagEmbeddingWarning";
import {
  ArrowLeft,
  Database,
  FileText,
  FolderSync,
  Github,
  Globe,
  Layers,
  Loader2,
  RefreshCw,
  Settings as SettingsIcon,
  Smartphone,
  Star,
  Upload,
} from "lucide-react";
import type {
  IndexingLLMSelection,
  LinkedFolderInfo,
  KnowledgeUploadPolicy,
  SyncFolderResponse,
} from "@/features/knowledge/model/types";
import {
  formatKnowledgeTimestamp,
  isMarginNoteKb,
  kbProvider,
  kbDetailSections,
  providerUsesEmbeddingMetadata,
  resolveKbStatus,
  type KbDetailSection,
  type KnowledgeBase,
} from "@/lib/knowledge-helpers";
import type { TaskState } from "@/hooks/useKnowledgeProgress";
import type { HistoryEntry } from "@/hooks/useKnowledgeHistory";
import KbStatusBadge from "./KbStatusBadge";
import KbTaskLogs from "./KbTaskLogs";
import KbIndexingRun from "./KbIndexingRun";
import KbFilesTab from "./KbFilesTab";
import KbDocumentsSection from "./KbDocumentsSection";
import KbIndexVersionsSection from "./KbIndexVersionsSection";
import KbSettingsSection from "./KbSettingsSection";
import KbGitHubSourcesSection from "./KbGitHubSourcesSection";
import KbLinkedFoldersSection from "./KbLinkedFoldersSection";
import KbWebSourcesSection from "./KbWebSourcesSection";
import KbMarginNoteDevicesSection from "./KbMarginNoteDevicesSection";
import KbKiwixArticlesSection from "./KbKiwixArticlesSection";
import KnowledgeEngineIcon, {
  knowledgeSourceIconId,
} from "./KnowledgeEngineIcon";

interface KnowledgeBaseDetailProps {
  kb: KnowledgeBase | null;
  uploadPolicy: KnowledgeUploadPolicy;
  task?: TaskState;
  history: HistoryEntry[];
  onCreate: () => void;
  onUpload: (
    kbName: string,
    files: File[],
    destSubdir?: string,
  ) => Promise<void>;
  onLinkFolder: (
    kbName: string,
    folderPath: string,
  ) => Promise<LinkedFolderInfo>;
  onUnlinkFolder: (kbName: string, folderId: string) => Promise<void>;
  onSyncFolder: (
    kbName: string,
    folderId: string,
  ) => Promise<SyncFolderResponse>;
  onReindex: (
    kbName: string,
    configFingerprint?: string,
    embeddingModel?: EmbeddingModelSelection,
  ) => Promise<void>;
  onRetry: (kbName: string) => Promise<void>;
  onSetDefault: (kbName: string) => Promise<void>;
  onDelete: (kbName: string) => Promise<void>;
  onMove?: (kbName: string, targetWorkspaceId: string) => Promise<void>;
  onClearHistory: (kbName: string) => void;
  onBack?: () => void;
}

const SECTION_CHROME: Record<
  KbDetailSection,
  { label: string; Icon: typeof FileText }
> = {
  files: { label: "Files", Icon: FileText },
  add: { label: "Add documents", Icon: Upload },
  folders: { label: "Linked folders", Icon: FolderSync },
  github: { label: "GitHub", Icon: Github },
  web: { label: "Web", Icon: Globe },
  versions: { label: "Index versions", Icon: Layers },
  devices: { label: "Devices", Icon: Smartphone },
  kiwix: { label: "Articles", Icon: FileText },
  settings: { label: "Settings", Icon: SettingsIcon },
};

/** Sections that fill the detail body edge-to-edge (no max-w wrapper). */
const FULL_BLEED_SECTIONS = new Set<KbDetailSection>(["files"]);

export default function KnowledgeBaseDetail({
  kb,
  uploadPolicy,
  task,
  history,
  onCreate,
  onUpload,
  onLinkFolder,
  onUnlinkFolder,
  onSyncFolder,
  onReindex,
  onRetry,
  onSetDefault,
  onDelete,
  onMove,
  onClearHistory,
  onBack,
}: KnowledgeBaseDetailProps) {
  const { t } = useTranslation();
  const [section, setSection] = useState<KbDetailSection>("files");
  const [retrySubmitting, setRetrySubmitting] = useState(false);

  if (!kb) {
    return (
      <main className="flex flex-1 items-center justify-center bg-[var(--background)] p-6">
        <div className="max-w-sm rounded-2xl border border-dashed border-[var(--border)] bg-[var(--card)]/40 p-8 text-center">
          <div className="mx-auto mb-4 flex h-12 w-12 items-center justify-center rounded-2xl bg-[var(--muted)] text-[var(--muted-foreground)]">
            <Database className="h-5 w-5" />
          </div>
          <div className="text-[14px] font-medium text-[var(--foreground)]">
            {t("No knowledge base selected")}
          </div>
          <p className="mx-auto mt-2 text-[12px] leading-relaxed text-[var(--muted-foreground)]">
            {t(
              "Pick a knowledge base from the list, or create a new one to get started.",
            )}
          </p>
          <button
            type="button"
            onClick={onCreate}
            className="mt-4 inline-flex items-center gap-1.5 rounded-lg bg-[var(--primary)] px-3.5 py-1.5 text-[13px] font-medium text-[var(--primary-foreground)] transition-opacity hover:opacity-90"
          >
            {t("Create your first knowledge base")}
          </button>
        </div>
      </main>
    );
  }

  const meta = kb.metadata || {};
  const isMarginNote = isMarginNoteKb(kb);
  // A MarginNote library records no engine and no embedding: defaulting to
  // "llamaindex · Default embedding" here described a pipeline it never runs.
  const provider = kb.metadata?.type === "kiwix"
    ? t("Kiwix / ZIM")
    : isMarginNote
    ? t("MarginNote 4")
    : kb.statistics?.rag_provider || "llamaindex";
  const pageIndexProvider =
    isMarginNote || kb.metadata?.type === "kiwix" || !providerUsesEmbeddingMetadata(provider);
  const embeddingLabel = meta.embedding_model
    ? typeof meta.embedding_dim === "number"
      ? `${meta.embedding_model} · ${meta.embedding_dim}${t("d")}`
      : meta.embedding_model
    : t("Default embedding");
  const updatedLabel =
    formatKnowledgeTimestamp(meta.last_updated) || t("Unknown time");
  const lastIndexedLabel = formatKnowledgeTimestamp(meta.last_indexed_at);

  const isReindexingLocally =
    (task?.kind === "reindex" || task?.kind === "retry") &&
    task.executing === true;
  const status = resolveKbStatus(kb);
  // Nothing to re-run: its content arrives from the add-on, not an index.
  const canRetry = status === "error" && !kb.read_only && !isMarginNote && kb.metadata?.type !== "kiwix";

  const handleRetry = async () => {
    if (!canRetry || retrySubmitting || isReindexingLocally) return;
    if (kbProvider(kb) === "lightrag") {
      setSection("versions");
      return;
    }
    setRetrySubmitting(true);
    try {
      await onRetry(knowledgeBaseRef(kb));
    } finally {
      setRetrySubmitting(false);
    }
  };

  const sections = kbDetailSections(kb);
  // Switching to a KB without the selected section (a MarginNote library has
  // no Files tab) falls back to its first, instead of rendering nothing.
  const activeSection = sections.includes(section) ? section : sections[0];
  const fullBleed = FULL_BLEED_SECTIONS.has(activeSection);

  return (
    <main className="flex h-full flex-1 flex-col overflow-hidden bg-[var(--background)]">
      <KnowledgeBaseCrumb id={kb.name} label={kb.name} />
      {/* Header */}
      <div className="border-b border-[var(--border)] bg-[var(--card)] px-6 py-4">
        <div className="flex items-start justify-between gap-3">
          <div className="flex min-w-0 flex-1 items-start gap-3">
            <KnowledgeEngineIcon
              engine={knowledgeSourceIconId({
                provider: kbProvider(kb),
                type: kb.metadata?.type,
              })}
              size={36}
              className="mt-0.5"
            />
            <div className="min-w-0 flex-1">
              {onBack && (
                <button
                  type="button"
                  onClick={onBack}
                  className="dt-section-back mb-1.5 inline-flex items-center gap-1 text-[11.5px] font-medium text-[var(--muted-foreground)] transition-colors hover:text-[var(--foreground)]"
                >
                  <ArrowLeft className="h-3.5 w-3.5" />
                  {t("Knowledge bases")}
                </button>
              )}
              <div className="flex flex-wrap items-center gap-2">
                <h1 className="truncate font-serif text-[18px] font-semibold tracking-tight text-[var(--foreground)]">
                  {kb.name}
                </h1>
                {kb.is_default && (
                  <span className="inline-flex items-center gap-1 rounded-full bg-amber-100 px-2 py-0.5 text-[10px] font-medium text-amber-700 dark:bg-amber-950/30 dark:text-amber-300">
                    <Star className="h-3 w-3" fill="currentColor" />
                    {t("Default")}
                  </span>
                )}
                {(kb.assigned || kb.provenance_label) && (
                  <span className="inline-flex items-center rounded-full bg-emerald-500/10 px-2 py-0.5 text-[10px] font-medium text-emerald-700 dark:text-emerald-300">
                    {kb.provenance_label || t("Assigned by admin")}
                  </span>
                )}
                <KbStatusBadge
                  kb={kb}
                  isReindexingLocally={isReindexingLocally}
                />
              </div>
              <p className="mt-1 text-[12px] text-[var(--muted-foreground)]">
                {provider}
                {!pageIndexProvider ? ` · ${embeddingLabel}` : ""} ·{" "}
                {t("Updated")} {updatedLabel}
                {lastIndexedLabel
                  ? ` · ${t("Last indexed")} ${lastIndexedLabel}`
                  : ""}
              </p>
              <LightRagEmbeddingWarning kb={kb} />
            </div>
          </div>
          {canRetry && (
            <Tooltip label={t(
                "Retry indexing from the documents already stored in this knowledge base.",
              )} side="top">
              <button
                type="button"
                onClick={handleRetry}
                disabled={retrySubmitting || isReindexingLocally}
                className="inline-flex shrink-0 items-center gap-1.5 rounded-md border border-red-200 bg-red-50 px-2.5 py-1 text-[12px] font-medium text-red-700 transition-colors hover:bg-red-100 disabled:opacity-50 dark:border-red-900 dark:bg-red-950/30 dark:text-red-300"
              >
                {retrySubmitting || isReindexingLocally ? (
                  <Loader2 className="h-3 w-3 animate-spin" />
                ) : (
                  <RefreshCw className="h-3 w-3" />
                )}
                {retrySubmitting || isReindexingLocally
                  ? t("Retrying…")
                  : t(
                      kbProvider(kb) === "lightrag"
                        ? "Review rebuild"
                        : "Retry indexing",
                    )}
              </button>
            </Tooltip>
          )}
        </div>

        {/* Section nav */}
        <nav className="-mb-3 mt-3 flex gap-1 overflow-x-auto">
          {sections.map((key) => {
            const { label, Icon } = SECTION_CHROME[key];
            const active = activeSection === key;
            return (
              <button
                key={key}
                type="button"
                onClick={() => setSection(key)}
                className={`inline-flex shrink-0 items-center gap-1.5 rounded-t-md px-3 py-2 text-[12.5px] font-medium transition-colors ${
                  active
                    ? "border-b-2 border-[var(--primary)] text-[var(--foreground)]"
                    : "border-b-2 border-transparent text-[var(--muted-foreground)] hover:text-[var(--foreground)]"
                }`}
              >
                <Icon size={13} />
                {t(label)}
              </button>
            );
          })}
        </nav>
      </div>

      {/* Body */}
      <KbTaskLogs key={knowledgeBaseRef(kb)} kb={kb} task={task} />
      <KbIndexingRun key={`run-${knowledgeBaseRef(kb)}`} kbName={knowledgeBaseRef(kb)} readOnly={kb.read_only} />
      <div className="min-h-0 flex-1 overflow-hidden">
        {activeSection === "files" ? (
          <KbFilesTab key={knowledgeBaseRef(kb)} kb={kb} task={task} />
        ) : (
          <div className="h-full overflow-y-auto px-6 py-5">
            <div className={fullBleed ? "" : "mx-auto max-w-3xl"}>
              {activeSection === "add" && (
                <KbDocumentsSection
                  kb={kb}
                  uploadPolicy={uploadPolicy}
                  task={task}
                  history={history}
                  onClearHistory={() => onClearHistory(knowledgeBaseRef(kb))}
                  onRetry={handleRetry}
                  onUpload={(files, destSubdir) =>
                    kb.read_only
                      ? Promise.resolve()
                      : onUpload(knowledgeBaseRef(kb), files, destSubdir)
                  }
                />
              )}
              {activeSection === "folders" && (
                <KbLinkedFoldersSection
                  key={knowledgeBaseRef(kb)}
                  kb={kb}
                  task={task}
                  onLinkFolder={async (folderPath) => {
                    await onLinkFolder(knowledgeBaseRef(kb), folderPath);
                  }}
                  onUnlinkFolder={(folderId) => onUnlinkFolder(knowledgeBaseRef(kb), folderId)}
                  onSyncFolder={(folderId) => onSyncFolder(knowledgeBaseRef(kb), folderId)}
                />
              )}
              {activeSection === "versions" && (
                <KbIndexVersionsSection
                  kb={kb}
                  task={task}
                  onReindex={(configFingerprint, embeddingModel) =>
                    kb.read_only
                      ? Promise.resolve()
                      : status === "error" &&
                          kbProvider(kb) !== "lightrag" &&
                          !embeddingModel
                        ? handleRetry()
                        : onReindex(
                            knowledgeBaseRef(kb),
                            configFingerprint,
                            embeddingModel,
                          )
                  }
                />
              )}
              {activeSection === "github" && (
                <KbGitHubSourcesSection kbName={knowledgeBaseRef(kb)} />
              )}
              {activeSection === "web" && (
                <KbWebSourcesSection kbName={knowledgeBaseRef(kb)} />
              )}
              {activeSection === "devices" && (
                <KbMarginNoteDevicesSection
                  key={knowledgeBaseRef(kb)}
                  kb={kb}
                />
              )}
              {activeSection === "kiwix" && (
                <KbKiwixArticlesSection key={knowledgeBaseRef(kb)} kb={kb} />
              )}
              {activeSection === "settings" && (
                <KbSettingsSection
                  kb={kb}
                  onMove={onMove ? (targetWorkspaceId) => onMove(knowledgeBaseRef(kb), targetWorkspaceId) : undefined}
                  onSetDefault={() =>
                    kb.read_only
                      ? Promise.resolve()
                      : onSetDefault(knowledgeBaseRef(kb))
                  }
                  onDelete={() =>
                    kb.read_only
                      ? Promise.resolve()
                      : onDelete(knowledgeBaseRef(kb))
                  }
                />
              )}
            </div>
          </div>
        )}
      </div>
    </main>
  );
}