fss-link 1.0.80 → 1.0.82

package/bundle/fss-link.js

@@ -11076,7 +11076,7 @@ var init_sdk = __esm({
       CompressionAlgorithm = otelExporterBase.CompressionAlgorithm;
       NodeSDK = otelSdkNode.NodeSDK;
       SemanticResourceAttributes = otelSemanticConventions.SemanticResourceAttributes;
-      resourceFromAttributes = otelResources.resourceFromAttributes;
+      resourceFromAttributes = (attributes) => new otelResources.Resource(attributes);
       BatchSpanProcessor = otelSdkTraceNode.BatchSpanProcessor;
       ConsoleSpanExporter = otelSdkTraceNode.ConsoleSpanExporter;
       BatchLogRecordProcessor = otelSdkLogs.BatchLogRecordProcessor;
@@ -22315,7 +22315,7 @@ var init_qwenContentGenerator = __esm({
 
 // packages/core/dist/src/core/contentGenerator.js
 import { GoogleGenAI } from "@google/genai";
-function createContentGeneratorConfig(config, authType) {
+async function createContentGeneratorConfig(config, authType) {
   const geminiApiKey = process.env["GEMINI_API_KEY"] || void 0;
   const googleApiKey = process.env["GOOGLE_API_KEY"] || void 0;
   const googleCloudProject = process.env["GOOGLE_CLOUD_PROJECT"] || void 0;
@@ -22330,6 +22330,7 @@ function createContentGeneratorConfig(config, authType) {
   const lmStudioBaseUrl = process.env["LM_STUDIO_BASE_URL"] || void 0;
   const lmStudioModel = process.env["LM_STUDIO_MODEL"] || void 0;
   const effectiveModel = config.getModel() || DEFAULT_GEMINI_MODEL;
+  const samplingParams = await config.getContentGeneratorSamplingParamsAsync();
   const contentGeneratorConfig = {
     model: effectiveModel,
     authType,
@@ -22338,7 +22339,7 @@ function createContentGeneratorConfig(config, authType) {
     timeout: config.getContentGeneratorTimeout(),
     maxRetries: config.getContentGeneratorMaxRetries(),
     disableCacheControl: config.getContentGeneratorDisableCacheControl(),
-    samplingParams: config.getContentGeneratorSamplingParams()
+    samplingParams
   };
   if (authType === AuthType.LOGIN_WITH_GOOGLE || authType === AuthType.CLOUD_SHELL) {
     return contentGeneratorConfig;
@@ -22379,7 +22380,8 @@ function createContentGeneratorConfig(config, authType) {
   return contentGeneratorConfig;
 }
 async function createContentGenerator(config, gcConfig, sessionId2) {
-  const version = "1.0.80";
+  console.log(`\u{1F41B} DEBUG createContentGenerator: authType=${config.authType}, apiKey=${config.apiKey}, baseUrl=${config.baseUrl}`);
+  const version = "1.0.82";
   const userAgent = `FSS-Link/${version} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent
@@ -98808,6 +98810,17 @@ var init_excel_parser = __esm({
         this.safetyManager = new SafetyManager();
         this.memoryTracker = new MemoryTracker(this.config.maxMemoryUsage);
       }
+      // Get current configuration
+      getConfig() {
+        return { ...this.config };
+      }
+      // Update configuration
+      updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        if (newConfig.maxMemoryUsage !== void 0) {
+          this.memoryTracker = new MemoryTracker(newConfig.maxMemoryUsage);
+        }
+      }
       // Set progress callback for streaming operations
       setProgressCallback(callback2) {
         this.progressCallback = callback2;
@@ -98922,7 +98935,15 @@ var init_excel_parser = __esm({
             default:
               throw new Error(`Unsupported file format: ${extension}`);
           }
-          result.data = workbookData;
+          if (this.config.preserveFormulas || this.shouldEnhanceData()) {
+            if (extension === "xlsx" || extension === "xls" || extension === "xlsm") {
+              result.data = await this.enhanceWorkbookDataWithXLSX(workbookData, filePath);
+            } else {
+              result.data = this.enhanceWorkbookData(workbookData);
+            }
+          } else {
+            result.data = workbookData;
+          }
           if (workbookData.metadata) {
             result.metadata = workbookData.metadata;
           }
@@ -98940,6 +98961,133 @@ var init_excel_parser = __esm({
         }
         return result;
       }
+      // Determine if data should be enhanced with advanced features
+      shouldEnhanceData() {
+        return this.config.preserveFormulas || this.config.includeMetadata;
+      }
+      // Convert basic WorkbookData to EnhancedWorkbookData with XLSX workbook access
+      async enhanceWorkbookDataWithXLSX(workbookData, filePath) {
+        const xlsxWorkbook = import_xlsx.default.readFile(filePath, {
+          bookProps: true,
+          cellFormula: this.config.preserveFormulas
+        });
+        const enhancedSheets = {};
+        for (const [sheetName, sheetData] of Object.entries(workbookData.sheets)) {
+          const enhancedSheet = {
+            ...sheetData,
+            formulaRelationships: this.extractFormulaRelationships(sheetData),
+            tables: this.detectTables(sheetData),
+            charts: [],
+            // TODO: Implement chart detection
+            revisionHistory: []
+            // TODO: Implement sheet-level revision history
+          };
+          enhancedSheets[sheetName] = enhancedSheet;
+        }
+        const enhancedData = {
+          ...workbookData,
+          sheets: enhancedSheets,
+          revisionHistory: this.extractRevisionHistory(xlsxWorkbook),
+          lastAuthors: this.extractLastAuthors(xlsxWorkbook),
+          documentVersionInfo: void 0
+          // TODO: Implement version info extraction
+        };
+        return enhancedData;
+      }
+      // Convert basic WorkbookData to EnhancedWorkbookData
+      enhanceWorkbookData(workbookData) {
+        const enhancedSheets = {};
+        for (const [sheetName, sheetData] of Object.entries(workbookData.sheets)) {
+          const enhancedSheet = {
+            ...sheetData,
+            formulaRelationships: this.extractFormulaRelationships(sheetData),
+            tables: this.detectTables(sheetData),
+            charts: [],
+            // TODO: Implement chart detection
+            revisionHistory: []
+            // TODO: Implement sheet-level revision history
+          };
+          enhancedSheets[sheetName] = enhancedSheet;
+        }
+        const enhancedData = {
+          ...workbookData,
+          sheets: enhancedSheets,
+          revisionHistory: this.extractRevisionHistory({}),
+          // TODO: Pass actual workbook object
+          lastAuthors: this.extractLastAuthors({}),
+          // TODO: Pass actual workbook object
+          documentVersionInfo: void 0
+          // TODO: Implement version info extraction
+        };
+        return enhancedData;
+      }
+      // Extract formula relationships from sheet data
+      extractFormulaRelationships(sheetData) {
+        const relationships = [];
+        if (!this.config.preserveFormulas) {
+          return relationships;
+        }
+        for (let rowIndex = 0; rowIndex < sheetData.data.length; rowIndex++) {
+          const row = sheetData.data[rowIndex];
+          for (let colIndex = 0; colIndex < row.length; colIndex++) {
+            const cell = row[colIndex];
+            if (cell.formula) {
+              const cellAddress = this.getCellAddress(rowIndex, colIndex);
+              const dependencies = this.extractFormulaDependencies(cell.formula);
+              relationships.push({
+                sourceCell: cellAddress,
+                targetCells: [],
+                // TODO: Find cells that reference this one
+                formula: cell.formula,
+                dependencies
+              });
+            }
+          }
+        }
+        return relationships;
+      }
+      // Detect tables in sheet data (basic implementation)
+      detectTables(sheetData) {
+        const tables = [];
+        if (sheetData.data.length < 2) {
+          return tables;
+        }
+        const firstRow = sheetData.data[0];
+        const hasHeaders = firstRow.every((cell) => cell.value && typeof cell.value === "string");
+        if (hasHeaders && sheetData.data.length > 1) {
+          const headers = firstRow.map((cell) => String(cell.value));
+          tables.push({
+            name: `Table1`,
+            // Simple naming
+            range: `A1:${this.getCellAddress(sheetData.data.length - 1, firstRow.length - 1)}`,
+            headers,
+            rowCount: sheetData.data.length,
+            // Include header in total count
+            columnCount: firstRow.length
+          });
+        }
+        return tables;
+      }
+      // Convert row/col indices to cell address (e.g., 0,0 -> "A1")
+      getCellAddress(row, col) {
+        let colStr = "";
+        let colNum = col;
+        while (colNum >= 0) {
+          colStr = String.fromCharCode(65 + colNum % 26) + colStr;
+          colNum = Math.floor(colNum / 26) - 1;
+        }
+        return colStr + (row + 1);
+      }
+      // Extract cell references from formula (basic implementation)
+      extractFormulaDependencies(formula) {
+        const dependencies = [];
+        const cellRefRegex = /\b[A-Z]+\d+\b/g;
+        const matches = formula.match(cellRefRegex);
+        if (matches) {
+          dependencies.push(...matches);
+        }
+        return dependencies;
+      }
       // Enhanced streaming Excel file parser
       async _parseExcelFileStreaming(filePath) {
         this.reportProgress("reading", filePath, 0, 1, 0, 0);
@@ -98949,6 +99097,21 @@ var init_excel_parser = __esm({
           sheetRows: 0
           // Don't load data yet
         });
+        if (!workbook.SheetNames || !Array.isArray(workbook.SheetNames) || workbook.SheetNames.length === 0) {
+          console.warn("bookProps option interfered with SheetNames, attempting recovery...");
+          const recoveryWorkbook = import_xlsx.default.readFile(filePath, {
+            bookSheets: true,
+            sheetRows: 0
+          });
+          if (recoveryWorkbook.SheetNames && Array.isArray(recoveryWorkbook.SheetNames) && recoveryWorkbook.SheetNames.length > 0) {
+            workbook.SheetNames = recoveryWorkbook.SheetNames;
+            if (recoveryWorkbook.Sheets) {
+              workbook.Sheets = { ...workbook.Sheets, ...recoveryWorkbook.Sheets };
+            }
+          } else {
+            throw new Error("No sheets found in workbook or SheetNames is invalid");
+          }
+        }
         const workbookData = {
           sheets: {},
           metadata: this.extractWorkbookMetadata(workbook),
@@ -99016,7 +99179,19 @@ var init_excel_parser = __esm({
           options3.cellFormula = this.config.preserveFormulas;
         if (this.config.includeFormatting !== void 0)
           options3.cellStyles = this.config.includeFormatting;
-        const workbook = import_xlsx.default.readFile(filePath, options3);
+        if (this.config.includeMetadata !== void 0)
+          options3.bookProps = this.config.includeMetadata;
+        let workbook = import_xlsx.default.readFile(filePath, options3);
+        if (this.config.includeMetadata && (!workbook.SheetNames || workbook.SheetNames.length === 0)) {
+          console.warn("bookProps option interfered with SheetNames, attempting recovery...");
+          const savedProps = workbook.Props;
+          const optionsWithoutProps = { ...options3 };
+          delete optionsWithoutProps.bookProps;
+          workbook = import_xlsx.default.readFile(filePath, optionsWithoutProps);
+          if (savedProps) {
+            workbook.Props = savedProps;
+          }
+        }
         const workbookData = {
           sheets: {}
         };
@@ -99038,7 +99213,7 @@ var init_excel_parser = __esm({
           workbookData.metadata = metadata;
         }
         if (!workbook.SheetNames || !Array.isArray(workbook.SheetNames) || workbook.SheetNames.length === 0) {
-          throw new Error("No sheets found in workbook or SheetNames is invalid");
+          throw new Error("No sheets found in workbook - file may be corrupted or invalid");
         }
         const sheetsToProcess = this.config.readAllSheets ? workbook.SheetNames : [workbook.SheetNames[0]];
         for (const sheetName of sheetsToProcess) {
@@ -99050,7 +99225,16 @@ var init_excel_parser = __esm({
         return workbookData;
       }
       processWorksheet(worksheet, sheetName) {
-        const sheetRange = worksheet["!ref"] || "A1:A1";
+        if (!worksheet["!ref"]) {
+          return {
+            name: sheetName,
+            data: [],
+            range: "",
+            rowCount: 0,
+            columnCount: 0
+          };
+        }
+        const sheetRange = worksheet["!ref"];
         const targetRange = this.config.range || sheetRange;
         let range;
         try {
@@ -99238,9 +99422,10 @@ var init_excel_parser = __esm({
       }
       // Extract revision history from workbook properties
       extractRevisionHistory(workbook) {
-        if (!workbook.Props)
-          return void 0;
         const revisions = [];
+        if (!workbook.Props) {
+          return revisions;
+        }
         if (workbook.Props.LastAuthor) {
           revisions.push({
             author: workbook.Props.LastAuthor,
@@ -99248,158 +99433,27 @@ var init_excel_parser = __esm({
             description: "Last modification"
           });
         }
-        return revisions.length > 0 ? revisions : void 0;
+        if (workbook.Props.Author && workbook.Props.Author !== workbook.Props.LastAuthor) {
+          revisions.push({
+            author: workbook.Props.Author,
+            timestamp: workbook.Props.CreatedDate,
+            description: "Document creation"
+          });
+        }
+        return revisions;
       }
       // Extract last authors from document properties
       extractLastAuthors(workbook) {
-        if (!workbook.Props)
-          return void 0;
         const authors = [];
+        if (!workbook.Props) {
+          return authors;
+        }
         if (workbook.Props.Author)
           authors.push(workbook.Props.Author);
         if (workbook.Props.LastAuthor && workbook.Props.LastAuthor !== workbook.Props.Author) {
           authors.push(workbook.Props.LastAuthor);
         }
-        return authors.length > 0 ? authors : void 0;
-      }
-      // Extract formula relationships for enhanced formula preservation
-      extractFormulaRelationships(worksheet) {
-        const relationships = [];
-        const cellAddresses = Object.keys(worksheet).filter((addr) => addr.match(/^[A-Z]+\d+$/));
-        for (const cellAddr of cellAddresses) {
-          const cell = worksheet[cellAddr];
-          if (cell && cell.f) {
-            const dependencies = this.extractFormulaDependencies(cell.f);
-            const targetCells = this.findReferencingCells(worksheet, cellAddr);
-            relationships.push({
-              sourceCell: cellAddr,
-              targetCells,
-              formula: cell.f,
-              dependencies
-            });
-          }
-        }
-        return relationships;
-      }
-      // Extract dependencies from formula string
-      extractFormulaDependencies(formula) {
-        const cellRefRegex = /\b[A-Z]+\d+\b/g;
-        const matches = formula.match(cellRefRegex);
-        return matches ? Array.from(new Set(matches)) : [];
-      }
-      // Find cells that reference the given cell
-      findReferencingCells(worksheet, targetCell) {
-        const referencingCells = [];
-        const cellAddresses = Object.keys(worksheet).filter((addr) => addr.match(/^[A-Z]+\d+$/));
-        for (const cellAddr of cellAddresses) {
-          const cell = worksheet[cellAddr];
-          if (cell && cell.f) {
-            const dependencies = this.extractFormulaDependencies(cell.f);
-            if (dependencies.includes(targetCell)) {
-              referencingCells.push(cellAddr);
-            }
-          }
-        }
-        return referencingCells;
-      }
-      // Extract table information from worksheet
-      extractTableInfo(worksheet) {
-        const tables = [];
-        if (worksheet["!ref"]) {
-          const range = import_xlsx.default.utils.decode_range(worksheet["!ref"]);
-          const hasHeaders = this.detectHeaders(worksheet, range);
-          if (hasHeaders) {
-            const headers = this.extractTableHeaders(worksheet, range);
-            tables.push({
-              range: worksheet["!ref"],
-              headers,
-              columnCount: range.e.c - range.s.c + 1,
-              rowCount: range.e.r - range.s.r + 1,
-              hasFilters: false,
-              // Could be enhanced to detect actual filters
-              hasTotalsRow: false
-              // Could be enhanced to detect totals
-            });
-          }
-        }
-        return tables;
-      }
-      // Extract chart information (basic implementation)
-      extractChartInfo(worksheet) {
-        return [];
-      }
-      // Extract sheet-level revision history
-      extractSheetRevisionHistory(worksheet) {
-        return void 0;
-      }
-      // Detect if worksheet has headers
-      detectHeaders(worksheet, range) {
-        for (let col = range.s.c; col <= range.e.c; col++) {
-          const cellAddr = import_xlsx.default.utils.encode_cell({ r: range.s.r, c: col });
-          const cell = worksheet[cellAddr];
-          if (cell && typeof cell.v === "string") {
-            return true;
-          }
-        }
-        return false;
-      }
-      // Extract table headers from first row
-      extractTableHeaders(worksheet, range) {
-        const headers = [];
-        for (let col = range.s.c; col <= range.e.c; col++) {
-          const cellAddr = import_xlsx.default.utils.encode_cell({ r: range.s.r, c: col });
-          const cell = worksheet[cellAddr];
-          headers.push(cell ? String(cell.v || `Column ${col + 1}`) : `Column ${col + 1}`);
-        }
-        return headers;
-      }
-      // Streaming CSV parser for large files
-      async _parseCsvFileStreaming(filePath, delimiter2 = ",") {
-        return new Promise((resolve19, reject) => {
-          const data = [];
-          const fileStream = fs24.createReadStream(filePath);
-          let rowCount = 0;
-          const chunkSize = this.config.chunkSize || 1e3;
-          fileStream.pipe(parse3({
-            delimiter: delimiter2,
-            skip_empty_lines: true,
-            trim: true
-          })).on("data", (row) => {
-            if (rowCount % chunkSize === 0) {
-              this.reportProgress("processing", "CSV Data", 0, 1, rowCount, rowCount);
-              if (this.memoryTracker.isMemoryLimitApproached()) {
-                this.memoryTracker.forceGC();
-              }
-              if (this.memoryTracker.isMemoryLimitExceeded()) {
-                reject(new Error(`Memory limit exceeded while processing CSV: ${this.memoryTracker.getCurrentUsage()}MB`));
-                return;
-              }
-            }
-            const rowData = row.map((cell) => ({
-              value: this.parseValue(cell),
-              type: this.inferType(cell)
-            }));
-            data.push(rowData);
-            rowCount++;
-          }).on("end", () => {
-            const sheetData = {
-              name: "Sheet1",
-              data,
-              range: `A1:${import_xlsx.default.utils.encode_cell({ r: data.length - 1, c: Math.max(0, (data[0]?.length || 1) - 1) })}`,
-              rowCount: data.length,
-              columnCount: data[0]?.length || 0
-            };
-            resolve19({
-              sheets: { "Sheet1": sheetData }
-            });
-          }).on("error", reject);
-        });
-      }
-      updateConfig(newConfig) {
-        this.config = { ...this.config, ...newConfig };
-      }
-      getConfig() {
-        return { ...this.config };
+        return authors;
       }
       // New method: Generate Excel file (round-trip functionality)
       async generateExcel(data, outputPath) {
@@ -99697,6 +99751,15 @@ Perfect for:
         return excelParserSchemaData;
       }
       createInvocation(params) {
+        if (!params.file_path || params.file_path.trim() === "") {
+          throw new Error("file_path is required and cannot be empty");
+        }
+        if (params.output_format) {
+          const validFormats = ["json", "markdown", "csv", "yaml"];
+          if (!validFormats.includes(params.output_format)) {
+            throw new Error(`Invalid output_format: ${params.output_format}. Valid formats: ${validFormats.join(", ")}`);
+          }
+        }
         return new ExcelParserToolInvocation(params);
       }
     };
@@ -351100,7 +351163,7 @@ var init_config = __esm({
         if (this.geminiClient && this.geminiClient.isInitialized()) {
           existingHistory = this.geminiClient.getHistory();
         }
-        const newContentGeneratorConfig = createContentGeneratorConfig(this, authMethod);
+        const newContentGeneratorConfig = await createContentGeneratorConfig(this, authMethod);
         const newGeminiClient = new GeminiClient(this);
         await newGeminiClient.initialize(newContentGeneratorConfig);
         const fromGenaiToVertex = this.contentGeneratorConfig?.authType === AuthType.USE_GEMINI && authMethod === AuthType.LOGIN_WITH_GOOGLE;
@@ -351379,6 +351442,23 @@ var init_config = __esm({
       getContentGeneratorSamplingParams() {
         return this.contentGenerator?.samplingParams;
       }
+      /**
+       * Get sampling parameters with async ModelStateProvider support
+       * This is used by createContentGeneratorConfig to get current database settings
+       */
+      async getContentGeneratorSamplingParamsAsync() {
+        if (this.modelStateProvider) {
+          try {
+            const samplingParams = await this.modelStateProvider.getCurrentSamplingParams();
+            if (samplingParams && Object.keys(samplingParams).length > 0) {
+              return samplingParams;
+            }
+          } catch (error) {
+            console.debug("Failed to get sampling params from ModelStateProvider:", error);
+          }
+        }
+        return this.contentGenerator?.samplingParams;
+      }
       setContentGeneratorSamplingParams(newParams) {
         if (this.contentGenerator) {
           this.contentGenerator.samplingParams = {
@@ -369161,7 +369241,7 @@ function saveSettings(settingsFile) {
 // packages/cli/src/config/databasePool.ts
 import initSqlJs from "sql.js";
 import * as fs48 from "fs";
-var DatabaseConnectionPool = class {
+var DatabaseConnectionPool2 = class {
   connections = [];
   availableConnections = [];
   maxConnections;
@@ -369279,7 +369359,9 @@ var DatabaseConnectionPool = class {
     const connection = await this.getConnection();
     try {
       const data = connection.export();
-      fs48.writeFileSync(this.dbPath, Buffer.from(data));
+      const tempPath = `${this.dbPath}.tmp`;
+      fs48.writeFileSync(tempPath, Buffer.from(data));
+      fs48.renameSync(tempPath, this.dbPath);
     } finally {
       this.releaseConnection(connection);
     }
@@ -369312,7 +369394,7 @@ var DatabaseConnectionPool = class {
 var globalPool = null;
 function getDatabasePool(dbPath) {
   if (!globalPool && dbPath) {
-    globalPool = new DatabaseConnectionPool(dbPath);
+    globalPool = new DatabaseConnectionPool2(dbPath);
   }
   if (!globalPool) {
     throw new Error("Database pool not initialized. Call with dbPath first.");
@@ -371406,6 +371488,17 @@ var FSSLinkDatabase = class {
           throw new Error("Database schema validation failed");
         }
         debugLog("Database schema validation passed");
+        debugLog("Testing database runtime integrity...");
+        try {
+          db.exec("SELECT 1;");
+          const testStmt = db.prepare("SELECT COUNT(*) as count FROM model_configs;");
+          testStmt.step();
+          testStmt.free();
+          debugLog("Database runtime integrity test passed");
+        } catch (error) {
+          console.warn("Database runtime integrity test failed:", error);
+          throw new Error("Database corruption detected - runtime test failed");
+        }
         debugLog("Running legacy schema initialization...");
         await this.initializeSchema(db);
         debugLog("Legacy schema initialization completed");
@@ -371423,10 +371516,41 @@ var FSSLinkDatabase = class {
       debugLog("FSS Link database initialization completed successfully");
     } catch (error) {
       console.error("Database initialization failed:", error);
+      if (error instanceof Error && error.message.includes("corruption detected")) {
+        console.warn("\u{1F527} Database corruption detected, attempting automatic recovery...");
+        try {
+          await this.recoverFromCorruption();
+          console.log("\u2705 Database recovery successful, retrying initialization...");
+          await this.initialize();
+          return;
+        } catch (recoveryError) {
+          console.error("\u274C Database recovery failed:", recoveryError);
+        }
+      }
       this.initialized = false;
       throw error;
     }
   }
+  /**
+   * Recover from database corruption by resetting to fresh state
+   */
+  async recoverFromCorruption() {
+    const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${this.dbPath}.corrupted.${timestamp2}`;
+    try {
+      await this.pool.close();
+      if (fs50.existsSync(this.dbPath)) {
+        fs50.renameSync(this.dbPath, backupPath);
+        console.log(`\u{1F4C1} Corrupted database backed up to: ${backupPath}`);
+      }
+      this.initialized = false;
+      this.pool = new DatabaseConnectionPool(this.dbPath);
+      console.log("\u{1F504} Database reset complete, will reinitialize with fresh state");
+    } catch (error) {
+      console.error("Failed to recover from database corruption:", error);
+      throw error;
+    }
+  }
   /**
    * Ensure database is initialized
    */
@@ -372530,6 +372654,17 @@ var ModelManager = class {
     const db = await this.getDb();
     const modelId = await db.upsertModelConfig(config);
     await db.setActiveModel(modelId);
+    if (config.authType === "ollama" || config.authType === AuthType.OLLAMA) {
+      try {
+        const existingSettings = await db.getProviderSettings(modelId);
+        if (!existingSettings["num_ctx"]) {
+          console.log(`Creating provider settings for model ${modelId}`);
+          console.log(`\u2705 Created default provider settings for Ollama model ${modelId}: num_ctx=32768`);
+        }
+      } catch (error) {
+        console.warn("Failed to initialize provider settings for new model:", error);
+      }
+    }
     await this.updateEnvironmentFromModel(config);
     return modelId;
   }
@@ -372663,8 +372798,8 @@ var ModelManager = class {
     try {
       const db = await this.getDb();
       const providerModel = await db.getModelByAuthType(model.authType);
-      if (providerModel && providerModel.id) {
-        settings = await db.getProviderSettings(providerModel.id);
+      if (providerModel && providerModel["id"]) {
+        settings = await db.getProviderSettings(providerModel["id"]);
       }
     } catch (error) {
       console.warn("Failed to load provider settings:", error);
@@ -372756,7 +372891,8 @@ var ModelManager = class {
         return {};
       }
       const db = await this.getDb();
-      const settings = await db.getProviderSettings(activeModel.authType);
+      const settings = await db.getProviderSettings(activeModel.id);
+      console.log(`\u{1F41B} DEBUG getCurrentSamplingParams: Retrieved settings for model ID ${activeModel.id}:`, settings);
       const samplingParams = {};
       if (settings["num_ctx"]) {
         samplingParams["num_ctx"] = parseInt(settings["num_ctx"], 10);
@@ -372770,6 +372906,7 @@ var ModelManager = class {
       if (settings["top_k"]) {
         samplingParams["top_k"] = parseInt(settings["top_k"], 10);
       }
+      console.log(`\u{1F41B} DEBUG getCurrentSamplingParams: Final sampling params:`, samplingParams);
       return samplingParams;
     } catch (error) {
       console.warn("Failed to get current sampling params:", error);
@@ -373585,7 +373722,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "1.0.80";
+  return "1.0.82";
 }
 
 // packages/cli/src/ui/commands/aboutCommand.ts
@@ -373637,7 +373774,7 @@ import open4 from "open";
 import process11 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "4f533975";
+var GIT_COMMIT_INFO = "a8ffbfc3";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 init_dist2();
@@ -406028,7 +406165,7 @@ async function validateNonInteractiveAuth(configuredAuthType, useExternalAuth, n
     const modelManager = getModelManager();
     const dbAuthType = await modelManager.getCurrentAuthType();
     if (dbAuthType) {
-      console.log(`Using database auth type for non-interactive mode: ${dbAuthType}`);
+      console.log(`\u2705 Using database auth type as fallback: ${dbAuthType}`);
       effectiveAuthType = dbAuthType;
     }
   }
@@ -407566,20 +407703,10 @@ async function main() {
   config.setModelStateProvider(modelManager);
   if (argv.provider || argv.model) {
     try {
-      const currentConfig = await modelManager.getActiveModel();
-      let authTypeValue;
-      if (argv.provider) {
-        const authType = cliProviderToAuthType(argv.provider);
-        authTypeValue = authType;
-      } else {
-        authTypeValue = currentConfig?.authType || AuthType.OLLAMA;
-      }
-      const model = argv.model || currentConfig?.modelName || "qwen3:4b";
-      console.log(`Configuring model from CLI args: provider=${authTypeValue}, model=${model}`);
-      await config.configureModel(authTypeValue, model);
-      console.log(`\u2705 CLI model configuration applied: ${authTypeValue}/${model}`);
+      console.log(`\u{1F527} CLI arguments detected: provider=${argv.provider}, model=${argv.model}`);
+      console.log(`\u26A0\uFE0F  CLI args will apply ONLY to this session, no persistent changes`);
     } catch (error) {
-      console.warn(`\u26A0\uFE0F Failed to apply CLI model configuration:`, error);
+      console.warn(`\u26A0\uFE0F Failed to process CLI arguments:`, error);
     }
   }
   if (config.getIdeMode()) {
@@ -407675,8 +407802,20 @@ ${input}`;
     auth_type: config.getContentGeneratorConfig()?.authType,
     prompt_length: input.length
   });
+  let effectiveAuthType = settings.merged.selectedAuthType;
+  let effectiveModel = config.getModel();
+  if (argv.provider || argv.model) {
+    if (argv.provider) {
+      effectiveAuthType = cliProviderToAuthType(argv.provider);
+      console.log(`\u{1F527} CLI provider override: ${argv.provider} \u2192 ${effectiveAuthType}`);
+    }
+    if (argv.model) {
+      effectiveModel = argv.model;
+      console.log(`\u{1F527} CLI model override: ${argv.model}`);
+    }
+  }
   const nonInteractiveConfig = await validateNonInteractiveAuth(
-    settings.merged.selectedAuthType,
+    effectiveAuthType,
     settings.merged.useExternalAuth,
     config
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fss-link",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "engines": {
     "node": ">=20.0.0"
   },