Skip to content

LLM Wiki is a cross-platform desktop application that turns your documents into an organized, interlinked knowledge base — automatically. Instead of traditional RAG (retrieve-and-answer from scratch every time), the LLM incrementally builds and maintains a persistent wiki from your sources。

TypeScript
3.6 KB
Raw Blame
import { create } from "zustand"
import type { WebSearchResult } from "@/lib/web-search"

export interface ResearchTask {
  id: string
  topic: string
  /** Review item that requested this research. It is resolved only after the
   * generated page has been written successfully. */
  sourceReviewId?: string
  rerunOfTaskId?: string
  searchQueries?: string[]
  status: "queued" | "searching" | "synthesizing" | "saving" | "done" | "error"
  webResults: WebSearchResult[]
  synthesis: string
  savedPath: string | null
  error: string | null
  createdAt: number
}

interface ResearchState {
  tasks: ResearchTask[]
  panelOpen: boolean
  maxConcurrent: number

  addTask: (topic: string) => string
  addTasks: (inputs: Array<Pick<ResearchTask, "topic" | "searchQueries" | "sourceReviewId" | "rerunOfTaskId">>) => string[]
  updateTask: (id: string, updates: Partial<ResearchTask>) => void
  removeTask: (id: string) => void
  setPanelOpen: (open: boolean) => void
  getRunningCount: () => number
  getNextQueued: () => ResearchTask | undefined
}

let counter = 0

const ACTIVE_RESEARCH_STATUSES = new Set<ResearchTask["status"]>([
  "queued",
  "searching",
  "synthesizing",
  "saving",
])

function researchLineageRoot(tasksById: ReadonlyMap<string, ResearchTask>, taskId: string): string {
  let current = taskId
  const visited = new Set<string>()
  while (!visited.has(current)) {
    visited.add(current)
    const parent = tasksById.get(current)?.rerunOfTaskId
    if (!parent) break
    current = parent
  }
  return current
}

export function hasActiveResearchRerun(tasks: readonly ResearchTask[], taskId: string): boolean {
  const tasksById = new Map(tasks.map((task) => [task.id, task]))
  const root = researchLineageRoot(tasksById, taskId)
  return tasks.some((task) =>
    task.id !== taskId &&
    ACTIVE_RESEARCH_STATUSES.has(task.status) &&
    researchLineageRoot(tasksById, task.id) === root,
  )
}

function createResearchTask(
  input: Pick<ResearchTask, "topic" | "searchQueries" | "sourceReviewId" | "rerunOfTaskId">,
): ResearchTask {
  return {
    id: `research-${++counter}`,
    topic: input.topic,
    ...(input.searchQueries?.length ? { searchQueries: input.searchQueries } : {}),
    ...(input.sourceReviewId ? { sourceReviewId: input.sourceReviewId } : {}),
    ...(input.rerunOfTaskId ? { rerunOfTaskId: input.rerunOfTaskId } : {}),
    status: "queued",
    webResults: [],
    synthesis: "",
    savedPath: null,
    error: null,
    createdAt: Date.now(),
  }
}

export const useResearchStore = create<ResearchState>((set, get) => ({
  tasks: [],
  panelOpen: false,
  maxConcurrent: 3,

  addTask: (topic) => {
    const task = createResearchTask({ topic })
    set((state) => ({
      tasks: [...state.tasks, task],
      panelOpen: true,
    }))
    return task.id
  },

  addTasks: (inputs) => {
    const tasks = inputs.map(createResearchTask)
    if (tasks.length === 0) return []
    set((state) => ({ tasks: [...state.tasks, ...tasks], panelOpen: true }))
    return tasks.map((task) => task.id)
  },

  updateTask: (id, updates) =>
    set((state) => ({
      tasks: state.tasks.map((t) => (t.id === id ? { ...t, ...updates } : t)),
    })),

  removeTask: (id) =>
    set((state) => ({
      tasks: state.tasks.filter((t) => t.id !== id),
    })),

  setPanelOpen: (panelOpen) => set({ panelOpen }),

  getRunningCount: () => {
    const { tasks } = get()
    return tasks.filter((t) =>
      t.status === "searching" || t.status === "synthesizing" || t.status === "saving"
    ).length
  },

  getNextQueued: () => {
    const { tasks } = get()
    return tasks.find((t) => t.status === "queued")
  },
}))