fix cached wiki doesn't load repo info and model info (#202)

Co-authored-by: chen zhang <[email protected]>

Author: zcuder

api/api.py

@@ -57,6 +57,15 @@ class ProcessedProjectEntry(BaseModel):
     submittedAt: int # Timestamp
     language: str # Extracted from filename
 
+class RepoInfo(BaseModel):
+    owner: str
+    repo: str
+    type: str
+    token: Optional[str] = None
+    localPath: Optional[str] = None
+    repoUrl: Optional[str] = None
+
+
 class WikiStructureModel(BaseModel):
     """
     Model for the overall wiki structure.
@@ -72,19 +81,20 @@ class WikiCacheData(BaseModel):
     """
     wiki_structure: WikiStructureModel
     generated_pages: Dict[str, WikiPage]
-    repo_url: Optional[str] = None  # Add repo_url to cache
+    repo: RepoInfo
+    provider: str
+    model: str
 
 class WikiCacheRequest(BaseModel):
     """
     Model for the request body when saving wiki cache.
     """
-    owner: str
-    repo: str
-    repo_type: str
+    repo: RepoInfo
     language: str
     wiki_structure: WikiStructureModel
     generated_pages: Dict[str, WikiPage]
-    repo_url: Optional[str] = None  # Add repo_url to cache request
+    provider: str
+    model: str
 
 class WikiExportRequest(BaseModel):
     """
@@ -402,13 +412,15 @@ async def read_wiki_cache(owner: str, repo: str, repo_type: str, language: str)
 
 async def save_wiki_cache(data: WikiCacheRequest) -> bool:
     """Saves wiki cache data to the file system."""
-    cache_path = get_wiki_cache_path(data.owner, data.repo, data.repo_type, data.language)
+    cache_path = get_wiki_cache_path(data.repo.owner, data.repo.repo, data.repo.type, data.language)
     logger.info(f"Attempting to save wiki cache. Path: {cache_path}")
     try:
         payload = WikiCacheData(
             wiki_structure=data.wiki_structure,
             generated_pages=data.generated_pages,
-            repo_url=data.repo_url
+            repo=data.repo,
+            provider=data.provider,
+            model=data.model
         )
         # Log size of data to be cached for debugging (avoid logging full content if large)
         try:
@@ -469,7 +481,7 @@ async def store_wiki_cache(request_data: WikiCacheRequest):
     if not supported_langs.__contains__(request_data.language):
         request_data.language = configs["lang_config"]["default"]
 
-    logger.info(f"Attempting to save wiki cache for {request_data.owner}/{request_data.repo} ({request_data.repo_type}), lang: {request_data.language}")
+    logger.info(f"Attempting to save wiki cache for {request_data.repo.owner}/{request_data.repo.repo} ({request_data.repo.type}), lang: {request_data.language}")
     success = await save_wiki_cache(request_data)
     if success:
         return {"message": "Wiki cache saved successfully"}

src/app/[owner]/[repo]/page.tsx

@@ -1522,13 +1522,10 @@ IMPORTANT:
             if (cachedData && cachedData.wiki_structure && cachedData.generated_pages && Object.keys(cachedData.generated_pages).length > 0) {
               console.log('Using server-cached wiki data');
 
-              // Update repoInfo with cached repo_url if not provided in URL
-              let updatedRepoInfo = effectiveRepoInfo;
-              if (cachedData.repo_url && !effectiveRepoInfo.repoUrl) {
-                updatedRepoInfo = { ...effectiveRepoInfo, repoUrl: cachedData.repo_url };
-                setEffectiveRepoInfo(updatedRepoInfo); // Update effective repo info state
-                console.log('Using cached repo_url:', cachedData.repo_url);
-              }
+              setSelectedModelState(cachedData.model);
+              setSelectedProviderState(cachedData.provider);
+              // Update repoInfo 
+              setEffectiveRepoInfo(cachedData.repo); 
 
               // Ensure the cached structure has sections and rootSections
               const cachedStructure = {
@@ -1703,16 +1700,14 @@ IMPORTANT:
               sections: wikiStructure.sections || [],
               rootSections: wikiStructure.rootSections || []
             };
-
             const dataToCache = {
-              owner: effectiveRepoInfo.owner,
-              repo: effectiveRepoInfo.repo,
-              repo_type: effectiveRepoInfo.type,
+              repo: effectiveRepoInfo,
               language: language,
               comprehensive: isComprehensiveView,
               wiki_structure: structureToCache,
               generated_pages: generatedPages,
-              repo_url: effectiveRepoInfo.repoUrl || repoUrl || undefined // Include repo_url in cache
+              provider: selectedProviderState,
+              model: selectedModelState
             };
             const response = await fetch(`/api/wiki_cache`, {
               method: 'POST',

src/components/Ask.tsx

@@ -76,6 +76,8 @@ const Ask: React.FC<AskProps> = ({
   const [researchComplete, setResearchComplete] = useState(false);
   const inputRef = useRef<HTMLInputElement>(null);
   const responseRef = useRef<HTMLDivElement>(null);
+  const providerRef = useRef(provider);
+  const modelRef = useRef(model);
 
   // Focus input on component mount
   useEffect(() => {
@@ -106,34 +108,43 @@ const Ask: React.FC<AskProps> = ({
   }, []);
 
   useEffect(() => {
-    const fetchDefaultModel = async () => {
+    providerRef.current = provider;
+    modelRef.current = model;
+  }, [provider, model]);
+
+  useEffect(() => {
+    const fetchModel = async () => {
       try {
         setIsLoading(true);
 
         const response = await fetch('/api/models/config');
-
         if (!response.ok) {
           throw new Error(`Error fetching model configurations: ${response.status}`);
         }
 
         const data = await response.json();
 
-        setSelectedProvider(data.defaultProvider);
+        // use latest provider/model ref to check
+        if(providerRef.current == '' || modelRef.current== '') {
+          setSelectedProvider(data.defaultProvider);
 
-        // Find the default provider and set its default model
-        const selectedProvider = data.providers.find((p:Provider) => p.id === data.defaultProvider);
-        if (selectedProvider && selectedProvider.models.length > 0) {
-          setSelectedModel(selectedProvider.models[0].id);
+          // Find the default provider and set its default model
+          const selectedProvider = data.providers.find((p:Provider) => p.id === data.defaultProvider);
+          if (selectedProvider && selectedProvider.models.length > 0) {
+            setSelectedModel(selectedProvider.models[0].id);
+          }
+        } else {
+          setSelectedProvider(providerRef.current);
+          setSelectedModel(modelRef.current);
         }
       } catch (err) {
         console.error('Failed to fetch model configurations:', err);
       } finally {
         setIsLoading(false);
       }
     };
-
     if(provider == '' || model == '') {
-      fetchDefaultModel()
+      fetchModel()
     }
   }, [provider, model]);