add liner function descriptions

Author: randomtask2000

src/lib/config/app.config.ts

@@ -1,5 +1,6 @@
 import appConfigJson from '../../app.config.json';
 
+// Application-wide configuration settings
 export const appConfig = {
   title: appConfigJson.title,
   description: appConfigJson.description,

src/lib/config/features.ts

@@ -1,3 +1,4 @@
+// Configuration flags for enabling/disabling features
 export interface FeatureFlags {
   dragDropUpload: boolean;
   clientSideRAG: boolean;
@@ -6,6 +7,7 @@ export interface FeatureFlags {
   ragContextDisplay: boolean;
 }
 
+// Default feature flag values
 export const DEFAULT_FEATURES: FeatureFlags = {
   dragDropUpload: true,
   clientSideRAG: true,
@@ -14,15 +16,18 @@ export const DEFAULT_FEATURES: FeatureFlags = {
   ragContextDisplay: true
 };
 
+// LocalStorage key for feature flags
 export const FEATURE_FLAG_STORAGE_KEY = 'webllm_feature_flags';
 
+// Manages feature flags with localStorage persistence
 export class FeatureManager {
   private flags: FeatureFlags;
 
   constructor() {
     this.flags = this.loadFlags();
   }
 
+  // Loads feature flags from localStorage
   private loadFlags(): FeatureFlags {
     try {
       const stored = localStorage.getItem(FEATURE_FLAG_STORAGE_KEY);
@@ -35,6 +40,7 @@ export class FeatureManager {
     return { ...DEFAULT_FEATURES };
   }
 
+  // Persists feature flags to localStorage
   private saveFlags(): void {
     try {
       localStorage.setItem(FEATURE_FLAG_STORAGE_KEY, JSON.stringify(this.flags));
@@ -43,60 +49,72 @@ export class FeatureManager {
     }
   }
 
+  // Checks if a feature is enabled
   isEnabled(feature: keyof FeatureFlags): boolean {
     return this.flags[feature];
   }
 
+  // Enables a specific feature
   enable(feature: keyof FeatureFlags): void {
     this.flags[feature] = true;
     this.saveFlags();
   }
 
+  // Disables a specific feature
   disable(feature: keyof FeatureFlags): void {
     this.flags[feature] = false;
     this.saveFlags();
   }
 
+  // Toggles a feature and returns new state
   toggle(feature: keyof FeatureFlags): boolean {
     this.flags[feature] = !this.flags[feature];
     this.saveFlags();
     return this.flags[feature];
   }
 
+  // Returns all current feature flags
   getAll(): FeatureFlags {
     return { ...this.flags };
   }
 
+  // Updates multiple feature flags at once
   setAll(flags: Partial<FeatureFlags>): void {
     this.flags = { ...this.flags, ...flags };
     this.saveFlags();
   }
 }
 
+// Singleton instance of feature manager
 export const featureManager = new FeatureManager();
 
 // RAG Settings
+// Configuration settings for RAG functionality
 export interface RAGSettings {
   chunkSize: number;
   overlapSize: number;
   searchAccuracy: number;
 }
 
+// Default RAG configuration values
 export const DEFAULT_RAG_SETTINGS: RAGSettings = {
   chunkSize: 300,
   overlapSize: 20, // Reduced from 50 to minimize repetition
   searchAccuracy: 50 // 0-100 scale, 50 is balanced
 };
 
+// LocalStorage key for RAG settings
 export const RAG_SETTINGS_STORAGE_KEY = 'webllm_rag_settings';
 
+// Manages RAG settings with localStorage persistence
 export class RAGSettingsManager {
   private settings: RAGSettings;
 
   constructor() {
     this.settings = this.loadSettings();
   }
 
+  // Loads RAG settings from localStorage
   private loadSettings(): RAGSettings {
     try {
       const stored = localStorage.getItem(RAG_SETTINGS_STORAGE_KEY);
@@ -109,6 +127,7 @@ export class RAGSettingsManager {
     return { ...DEFAULT_RAG_SETTINGS };
   }
 
+  // Persists RAG settings to localStorage
   private saveSettings(): void {
     try {
       localStorage.setItem(RAG_SETTINGS_STORAGE_KEY, JSON.stringify(this.settings));
@@ -117,36 +136,44 @@ export class RAGSettingsManager {
     }
   }
 
+  // Gets current chunk size setting
   getChunkSize(): number {
     return this.settings.chunkSize;
   }
 
+  // Sets chunk size with bounds validation
   setChunkSize(size: number): void {
     this.settings.chunkSize = Math.max(50, Math.min(1000, size));
     this.saveSettings();
   }
 
+  // Gets current overlap size setting
   getOverlapSize(): number {
     return this.settings.overlapSize;
   }
 
+  // Sets overlap size with bounds validation
   setOverlapSize(size: number): void {
     this.settings.overlapSize = Math.max(0, Math.min(200, size));
     this.saveSettings();
   }
 
+  // Returns all current RAG settings
   getAll(): RAGSettings {
     return { ...this.settings };
   }
 
+  // Gets current search accuracy setting
   getSearchAccuracy(): number {
     return this.settings.searchAccuracy;
   }
 
+  // Sets search accuracy with bounds validation
   setSearchAccuracy(accuracy: number): void {
     this.settings.searchAccuracy = Math.max(0, Math.min(100, accuracy));
     this.saveSettings();
   }
 }
 
+// Singleton instance of RAG settings manager
 export const ragSettingsManager = new RAGSettingsManager();

src/lib/services/document-storage.ts

@@ -9,6 +9,7 @@ import type { RAGDocument } from '$lib/types/rag';
 
 const STORAGE_KEY = 'document_browser_storage';
 
+// Document structure for browser storage
 export interface StoredDocument {
   id: string;
   fileName: string;
@@ -28,14 +29,17 @@ export interface StoredDocument {
   updatedAt: Date;
 }
 
+// Service for managing document storage in browser
 class DocumentStorageService {
   private documents: Map<string, StoredDocument> = new Map();
 
   // Initializes service and loads stored documents
+  // Initializes service and loads existing documents
   constructor() {
     this.loadFromStorage();
   }
 
+  // Loads documents from localStorage
   // Loads documents from localStorage
   private loadFromStorage(): void {
     try {
@@ -56,6 +60,7 @@ class DocumentStorageService {
     }
   }
 
+  // Persists documents to localStorage
   // Persists documents to localStorage
   private saveToStorage(): void {
     try {
@@ -67,6 +72,7 @@ class DocumentStorageService {
   }
 
   // Processes and stores document with metadata
+  // Processes and stores a new document
   async addDocument(file: File): Promise<StoredDocument> {
     const id = crypto.randomUUID();
     const now = new Date();
@@ -135,19 +141,22 @@ class DocumentStorageService {
     }
   }
 
+  // Retrieves document by ID
   // Retrieves document by ID
   getDocument(id: string): StoredDocument | null {
     return this.documents.get(id) || null;
   }
 
   // Returns all documents sorted by date
+  // Returns all documents sorted by creation date
   getAllDocuments(): StoredDocument[] {
     return Array.from(this.documents.values()).sort(
       (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
     );
   }
 
   // Deletes document and updates storage
+  // Deletes document and returns success status
   removeDocument(id: string): boolean {
     const deleted = this.documents.delete(id);
     if (deleted) {
@@ -156,6 +165,7 @@ class DocumentStorageService {
     return deleted;
   }
 
+  // Determines file type from extension
   // Determines file type from extension
   private getFileType(fileName: string): string {
     const extension = fileName.toLowerCase().split('.').pop();
@@ -178,6 +188,7 @@ class DocumentStorageService {
   }
 
   // Converts to RAG-compatible format
+  // Converts stored document to RAG format
   toRAGDocument(storedDoc: StoredDocument): RAGDocument {
     return {
       id: storedDoc.id,
@@ -200,6 +211,7 @@ class DocumentStorageService {
   }
 
   // Clears all stored documents
+  // Removes all documents from storage
   clear(): void {
     this.documents.clear();
     localStorage.removeItem(STORAGE_KEY);

src/lib/services/rag-service.ts

@@ -8,19 +8,22 @@ import type {
 import { featureManager, ragSettingsManager } from '$lib/config/features';
 import { processDocument } from '$lib/utils/document-processor';
 
+// Client-side implementation of RAG service for document search
 export class ClientRAGService implements RAGService {
   private embeddingProvider: EmbeddingProvider | null = null;
   private vectorStore: VectorStore | null = null;
   private isInitialized = false;
   private lastReadyState: boolean | undefined;
 
   // Creates RAG service with optional providers
+  // Initializes RAG service with optional providers
   constructor(embeddingProvider?: EmbeddingProvider, vectorStore?: VectorStore) {
     if (embeddingProvider) this.embeddingProvider = embeddingProvider;
     if (vectorStore) this.vectorStore = vectorStore;
   }
 
   // Initializes RAG service with required providers
+  // Sets up embedding provider and vector store
   async initialize(embeddingProvider: EmbeddingProvider, vectorStore: VectorStore): Promise<void> {
     console.log('[RAGService] initialize called');
     console.log('[RAGService] clientSideRAG feature enabled:', featureManager.isEnabled('clientSideRAG'));
@@ -39,6 +42,7 @@ export class ClientRAGService implements RAGService {
     console.log('[RAGService] Initialization complete. isInitialized:', this.isInitialized);
   }
 
+  // Checks if service is ready for operations
   // Checks if service is ready for operations
   isReady(): boolean {
     const isInitialized = this.isInitialized;
@@ -63,6 +67,7 @@ export class ClientRAGService implements RAGService {
     return isReady;
   }
 
+  // Processes and adds document to RAG system
   // Processes and adds document to RAG system
   async addDocument(file: File): Promise<string> {
     if (!this.isReady()) {
@@ -144,6 +149,7 @@ export class ClientRAGService implements RAGService {
   }
 
   // Removes document from RAG system
+  // Removes document from vector store
   async removeDocument(documentId: string): Promise<void> {
     if (!this.isReady()) {
       throw new Error('RAG service is not ready');
@@ -153,6 +159,7 @@ export class ClientRAGService implements RAGService {
   }
 
   // Searches for relevant documents using semantic and keyword search
+  // Searches documents using semantic and keyword search
   async search(query: string, topK = 3): Promise<RAGQueryResult> {
     if (!this.isReady()) {
       throw new Error('RAG service is not ready');
@@ -252,6 +259,7 @@ export class ClientRAGService implements RAGService {
   }
 
   // Retrieves all documents from vector store
+  // Retrieves all stored documents
   async getDocuments(): Promise<RAGDocument[]> {
     if (!this.isReady()) {
       return [];
@@ -261,6 +269,7 @@ export class ClientRAGService implements RAGService {
   }
 
   // Splits document into semantic chunks with overlap
+  // Splits document into overlapping chunks
   private async chunkDocument(document: RAGDocument): Promise<any[]> {
     const CHUNK_SIZE = ragSettingsManager.getChunkSize();
     const OVERLAP = ragSettingsManager.getOverlapSize();
@@ -338,6 +347,7 @@ export class ClientRAGService implements RAGService {
     return chunks;
   }
 
+  // Generates embeddings for all document chunks
   // Generates embeddings for all document chunks
   private async generateEmbeddings(document: RAGDocument): Promise<void> {
     if (!this.embeddingProvider) return;
@@ -347,6 +357,7 @@ export class ClientRAGService implements RAGService {
     }
   }
 
+  // Performs keyword-based search on documents
   // Performs keyword-based search on documents
   private async keywordSearch(query: string, topK: number, accuracy: number): Promise<any[]> {
     const documents = await this.vectorStore!.getAllDocuments();

src/lib/services/vector-store.ts

@@ -6,11 +6,13 @@ const DB_VERSION = 1;
 const DOCUMENTS_STORE = 'documents';
 const CHUNKS_STORE = 'chunks';
 
+// IndexedDB-based vector store for persistent document storage
 export class IndexedDBVectorStore implements VectorStore {
   private db: IDBDatabase | null = null;
   private isInitialized = false;
 
   // Creates IndexedDB vector store instance
+  // Initializes vector store without immediate DB connection
   constructor() {
     console.log('[IndexedDBVectorStore] Constructor called');
     // Don't initialize in constructor - wait for explicit waitForReady call

src/lib/stores/models.ts

@@ -9,6 +9,7 @@ export const modelLoadingProgress = writable<number>(0);
 export const modelLoadingStatus = writable<string>('');
 export const cachedModels = writable<Set<string>>(new Set());
 
+// List of available WebLLM models with metadata
 export const MODELS: ModelInfo[] = [
   // Lightweight/Fast Models
   {
@@ -170,6 +171,7 @@ export function setModelDownloaded(modelId: string) {
 }
 
 // Checks which models are cached locally
+// Checks which models are cached and updates store
 export async function checkCachedModels(): Promise<void> {
   console.log('🔍 Checking cached models...');
   const { webLLMService } = await import('../utils/webllm');