fss-link 1.2.13 → 1.2.16

package/bundle/fss-link.js

@@ -19810,16 +19810,19 @@ var init_openaiContentGenerator = __esm({
           } : isDashScopeProvider ? {
             "X-DashScope-CacheControl": "enable",
             "X-DashScope-UserAgent": userAgent,
-            "X-DashScope-AuthType": contentGeneratorConfig.authType
+            "X-DashScope-AuthType": String(contentGeneratorConfig.authType ?? "")
           } : {}
         };
-        this.client = new OpenAI({
+        const clientConfig = {
           apiKey: contentGeneratorConfig.apiKey,
-          baseURL: contentGeneratorConfig.baseUrl,
           timeout: contentGeneratorConfig.timeout ?? 12e4,
           maxRetries: contentGeneratorConfig.maxRetries ?? 3,
           defaultHeaders
-        });
+        };
+        if (contentGeneratorConfig.baseUrl && contentGeneratorConfig.baseUrl.trim() !== "") {
+          clientConfig["baseURL"] = contentGeneratorConfig.baseUrl;
+        }
+        this.client = new OpenAI(clientConfig);
       }
       /**
        * Hook for subclasses to customize error handling behavior
@@ -19869,11 +19872,7 @@ var init_openaiContentGenerator = __esm({
         if (this.contentGeneratorConfig.authType === "ollama") {
           return true;
         }
-        const baseUrl = this.contentGeneratorConfig.baseUrl;
-        if (!baseUrl)
-          return false;
-        return baseUrl.includes("localhost:11434") || baseUrl.includes("127.0.0.1:11434") || baseUrl.includes(":11434/v1") || baseUrl.includes(":11435/v1") || // Support proxy port
-        baseUrl.includes("/ollama");
+        return false;
       }
       /**
        * Determine if this is a custom OpenAI-compatible endpoint (proxy, local server, etc.)
@@ -22268,7 +22267,9 @@ async function createContentGeneratorConfig(config, authType) {
   }
   if (authType === AuthType.USE_OPENAI && openaiApiKey) {
     contentGeneratorConfig.apiKey = openaiApiKey;
-    contentGeneratorConfig.baseUrl = openaiBaseUrl;
+    if (openaiBaseUrl && openaiBaseUrl.trim() !== "") {
+      contentGeneratorConfig.baseUrl = openaiBaseUrl;
+    }
     contentGeneratorConfig.model = openaiModel || DEFAULT_QWEN_MODEL;
     return contentGeneratorConfig;
   }
@@ -22342,7 +22343,7 @@ async function createContentGeneratorConfig(config, authType) {
 async function createContentGenerator(config, gcConfig, sessionId2) {
   if (DEBUG_CONTENT)
     console.log(`\u{1F41B} DEBUG createContentGenerator: authType=${config.authType}, apiKey=${config.apiKey}, baseUrl=${config.baseUrl}`);
-  const version = "1.2.13";
+  const version = "1.2.16";
   const userAgent = `FSS-Link/${version} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent
@@ -60695,7 +60696,7 @@ var init_project_structure = __esm({
     init_text_analyzer();
     projectStructureToolSchemaData = {
       name: "project_structure",
-      description: "Analyze and visualize project structure with intelligent insights. Goes beyond basic tree to provide architecture analysis, file relationships, and development guidance.",
+      description: "Query project files with focused filters and smart defaults. Use query parameters for targeted searches (large files, recent changes, specific types) or no parameters for concise overview.",
       parametersJsonSchema: {
         type: "object",
         properties: {
@@ -60704,9 +60705,74 @@ var init_project_structure = __esm({
             description: "Directory to analyze (defaults to current directory)",
             default: "."
           },
+          query: {
+            type: "object",
+            description: "Focused query parameters for targeted file searches (takes precedence over analysis_type)",
+            properties: {
+              where: {
+                type: "object",
+                description: "Filter conditions",
+                properties: {
+                  extension: {
+                    description: 'File extension(s) to match (e.g., "ts" or ["ts", "tsx"])'
+                  },
+                  size_gt: {
+                    type: "number",
+                    description: "Minimum file size in bytes"
+                  },
+                  size_lt: {
+                    type: "number",
+                    description: "Maximum file size in bytes"
+                  },
+                  path_contains: {
+                    type: "string",
+                    description: "Path must contain this string"
+                  },
+                  is_entry_point: {
+                    type: "boolean",
+                    description: "Filter to entry point files"
+                  },
+                  is_config: {
+                    type: "boolean",
+                    description: "Filter to configuration files"
+                  },
+                  modified_within_days: {
+                    type: "number",
+                    description: "Files modified within N days"
+                  },
+                  depth_lte: {
+                    type: "number",
+                    description: "Maximum directory depth"
+                  }
+                }
+              },
+              group_by: {
+                type: "string",
+                description: "Group results by field",
+                enum: ["extension", "directory"]
+              },
+              order_by: {
+                type: "string",
+                description: "Sort field",
+                enum: ["path", "size", "modified"],
+                default: "modified"
+              },
+              order_dir: {
+                type: "string",
+                description: "Sort direction",
+                enum: ["asc", "desc"],
+                default: "desc"
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of results",
+                default: 20
+              }
+            }
+          },
           analysis_type: {
             type: "string",
-            description: "Type of analysis to perform",
+            description: "Legacy: Type of analysis to perform (use query for focused searches)",
             enum: ["tree", "overview", "architecture", "metrics", "dependencies", "content"],
             default: "overview"
           },
@@ -60746,31 +60812,36 @@ var init_project_structure = __esm({
       }
     };
     projectStructureToolDescription = `
-Intelligent project structure analysis and visualization tool for development workflows.
+Query project files with focused filters and smart defaults.
 
-Analysis Types:
-- **tree**: Enhanced directory tree with file type icons and metadata
-- **overview**: High-level project summary with entry points and key files
-- **architecture**: Module relationships and dependency analysis
-- **metrics**: Code metrics, file sizes, and complexity analysis
-- **dependencies**: Package dependencies and version analysis
-- **content**: Text analysis with readability scores, complexity ratings, and documentation quality
+**RECOMMENDED: Use query mode for targeted searches**
 
-Features:
-- Smart file type detection with appropriate icons
-- Git integration (modified files, commit history)
-- Large file and bloat detection
-- Entry point and configuration file identification
-- Module import/export analysis
-- Architecture pattern recognition
-- Technology stack detection
+Common Query Patterns:
+- Large files: { query: { where: { size_gt: 100000 }, order_by: 'size', limit: 10 } }
+- Recent changes: { query: { where: { modified_within_days: 7 }, order_by: 'modified' } }
+- TypeScript files: { query: { where: { extension: ['ts', 'tsx'] } } }
+- File type distribution: { query: { group_by: 'extension' } }
+- Config files: { query: { where: { is_config: true } } }
+- Entry points: { query: { where: { is_entry_point: true } } }
 
-Perfect for:
-- Understanding unfamiliar codebases
-- Identifying architectural issues
-- Finding entry points and key files
-- Detecting bloat and unused files
-- Planning refactoring efforts
+Query Parameters:
+- **where**: Filter conditions (extension, size_gt/lt, path_contains, is_entry_point, is_config, modified_within_days, depth_lte)
+- **group_by**: Group results (extension, directory)
+- **order_by**: Sort field (path, size, modified)
+- **limit**: Max results (default: 20)
+
+Smart Default (no parameters):
+Returns concise project overview with entry points, recent changes, and largest files (~20 lines).
+
+Legacy Analysis Types (deprecated - use query instead):
+- overview: Project summary
+- content: Text analysis (expensive, opt-in only)
+
+Features:
+- Focused queries (10-20 line results vs 50-100 line dumps)
+- Smart filtering and aggregation
+- File type detection with icons
+- Size and modification time analysis
 `;
     ProjectStructureToolInvocation = class extends BaseToolInvocation {
       constructor(params) {
@@ -60781,7 +60852,7 @@ Perfect for:
         return `Analyze project structure (${analysis_type}) for ${target}`;
       }
       async execute(_signal) {
-        const { target = ".", analysis_type = "overview", max_depth = 5, show_hidden = false, file_types, exclude_patterns = ["node_modules", ".git", "__pycache__", "dist", "build"], size_analysis = true, git_awareness = true } = this.params;
+        const { target = ".", analysis_type = "overview", max_depth = 5, show_hidden = false, file_types, exclude_patterns = ["node_modules", ".git", "__pycache__", "dist", "build"], size_analysis = true, git_awareness = true, query } = this.params;
         try {
           const targetPath = path27.resolve(target);
           try {
@@ -60804,6 +60875,20 @@ Perfect for:
               returnDisplay: `\u274C Directory does not exist: ${target}`
             };
           }
+          if (query) {
+            const results = await this.executeQuery(targetPath, query, exclude_patterns);
+            const display2 = this.formatQueryResults(results, query);
+            return {
+              llmContent: JSON.stringify({
+                success: true,
+                mode: "query",
+                target: targetPath,
+                query,
+                results: results.summary || { files: results.files.map((f) => ({ path: f.path, size: f.size })) }
+              }),
+              returnDisplay: display2
+            };
+          }
           let analysis;
           switch (analysis_type) {
             case "tree":
@@ -61474,6 +61559,148 @@ Perfect for:
         }
         return `${size.toFixed(1)} ${units[unitIndex]}`;
       }
+      // ========== QUERY MODE IMPLEMENTATION ==========
+      /**
+       * Execute a focused query on project files
+       */
+      async executeQuery(targetPath, query, excludePatterns) {
+        const maxDepth = query.where?.depth_lte ?? 10;
+        const structure = await this.scanDirectory(targetPath, "", 0, maxDepth, false, excludePatterns);
+        let filtered = this.applyQueryFilters(structure, query.where);
+        if (query.order_by) {
+          filtered = this.applyQueryOrdering(filtered, query.order_by, query.order_dir ?? "desc");
+        }
+        const limit2 = query.limit ?? 20;
+        filtered = filtered.slice(0, limit2);
+        if (query.group_by) {
+          return this.applyQueryGrouping(filtered, query.group_by);
+        }
+        return { files: filtered };
+      }
+      /**
+       * Apply query filters to file list
+       */
+      applyQueryFilters(files, where) {
+        if (!where)
+          return files;
+        return files.filter((file) => {
+          if (where.extension) {
+            const extensions = Array.isArray(where.extension) ? where.extension : [where.extension];
+            if (file.extension && !extensions.includes(file.extension))
+              return false;
+          }
+          if (where.size_gt !== void 0 && file.size <= where.size_gt)
+            return false;
+          if (where.size_lt !== void 0 && file.size >= where.size_lt)
+            return false;
+          if (where.path_contains && !file.path.includes(where.path_contains))
+            return false;
+          if (where.is_entry_point !== void 0 && file.isEntryPoint !== where.is_entry_point)
+            return false;
+          if (where.is_config !== void 0 && file.isConfig !== where.is_config)
+            return false;
+          if (where.modified_within_days !== void 0) {
+            const daysSinceModified = (Date.now() - file.lastModified.getTime()) / (1e3 * 60 * 60 * 24);
+            if (daysSinceModified > where.modified_within_days)
+              return false;
+          }
+          if (where.depth_lte !== void 0) {
+            const depth = file.path.split("/").length;
+            if (depth > where.depth_lte)
+              return false;
+          }
+          return true;
+        });
+      }
+      /**
+       * Apply ordering to filtered files
+       */
+      applyQueryOrdering(files, orderBy, orderDir) {
+        const sorted = [...files];
+        const multiplier = orderDir === "asc" ? 1 : -1;
+        sorted.sort((a, b) => {
+          switch (orderBy) {
+            case "size":
+              return (b.size - a.size) * multiplier;
+            case "modified":
+              return (b.lastModified.getTime() - a.lastModified.getTime()) * multiplier;
+            case "path":
+            default:
+              return a.path.localeCompare(b.path) * multiplier;
+          }
+        });
+        return sorted;
+      }
+      /**
+       * Apply grouping and aggregation
+       */
+      applyQueryGrouping(files, groupBy) {
+        const groups = {};
+        files.forEach((file) => {
+          let key;
+          switch (groupBy) {
+            case "extension":
+              key = file.extension || "no-extension";
+              break;
+            case "directory":
+              key = file.path.split("/")[0] || "root";
+              break;
+            default:
+              key = "unknown";
+          }
+          if (!groups[key])
+            groups[key] = [];
+          groups[key].push(file);
+        });
+        const summary = {};
+        Object.keys(groups).forEach((key) => {
+          const groupFiles2 = groups[key];
+          summary[key] = {
+            count: groupFiles2.length,
+            total_size: groupFiles2.reduce((sum, f) => sum + f.size, 0),
+            files: groupFiles2.slice(0, 5).map((f) => f.path)
+          };
+        });
+        return { files, summary };
+      }
+      /**
+       * Format query results for display
+       */
+      formatQueryResults(results, query) {
+        let output = "";
+        if (results.summary) {
+          output += `**Query Results (grouped by ${query.group_by}):**
+
+`;
+          Object.entries(results.summary).forEach(([key, value]) => {
+            output += `**${key}:** ${value.count} files, ${this.formatSize(value.total_size)}
+`;
+            if (value.files && value.files.length > 0) {
+              value.files.forEach((filePath) => {
+                output += `  \u2022 ${filePath}
+`;
+              });
+            }
+            output += "\n";
+          });
+        } else {
+          output += `**Query Results:** ${results.files.length} files
+
+`;
+          results.files.forEach((file) => {
+            output += `${file.icon} ${file.path}`;
+            if (query.select?.includes("size") || !query.select) {
+              output += ` (${this.formatSize(file.size)})`;
+            }
+            if (query.select?.includes("modified") || !query.select) {
+              const daysAgo = Math.floor((Date.now() - file.lastModified.getTime()) / (1e3 * 60 * 60 * 24));
+              output += ` - ${daysAgo}d ago`;
+            }
+            output += "\n";
+          });
+        }
+        return output;
+      }
     };
     ProjectStructureTool = class _ProjectStructureTool extends BaseDeclarativeTool {
       static Name = projectStructureToolSchemaData.name;
@@ -68754,7 +68981,7 @@ var init_turn = __esm({
             /*curated*/
             true
           ), req];
-          await reportError(error, "Error when talking to Gemini API", contextForReport, "Turn.run-sendMessageStream");
+          await reportError(error, "Error when talking to LLM API", contextForReport, "Turn.run-sendMessageStream");
           const status = typeof error === "object" && error !== null && "status" in error && typeof error.status === "number" ? error.status : void 0;
           const structuredError = {
             message: getErrorMessage(error),
@@ -82286,6 +82513,12 @@ function loadSettings(workspaceDir) {
 }
 function saveSettings(settingsFile) {
   try {
+    console.log("[SETTINGS DEBUG] saveSettings called:", {
+      path: settingsFile.path,
+      dirname: path56.dirname(settingsFile.path),
+      keys: Object.keys(settingsFile.settings),
+      stackTrace: new Error().stack?.split("\n").slice(2, 6).join("\n")
+    });
     const dirPath = path56.dirname(settingsFile.path);
     if (!fs49.existsSync(dirPath)) {
       fs49.mkdirSync(dirPath, { recursive: true });
@@ -86199,7 +86432,11 @@ var init_modelManager = __esm({
           case AuthType.USE_OPENAI:
           case "openai":
             process.env["OPENAI_API_KEY"] = model.apiKey || "";
-            process.env["OPENAI_BASE_URL"] = model.endpointUrl || "";
+            if (model.endpointUrl && model.endpointUrl.trim() !== "") {
+              process.env["OPENAI_BASE_URL"] = model.endpointUrl;
+            } else {
+              delete process.env["OPENAI_BASE_URL"];
+            }
             process.env["OPENAI_MODEL"] = model.modelName || "";
             break;
           case AuthType.OLLAMA:
@@ -95173,7 +95410,7 @@ async function getPackageJson() {
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "1.2.13";
+  return "1.2.16";
 }
 
 // packages/cli/src/ui/commands/aboutCommand.ts
@@ -95225,7 +95462,7 @@ import open4 from "open";
 import process11 from "node:process";
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO = "01a88da5";
+var GIT_COMMIT_INFO = "a766b474";
 
 // packages/cli/src/ui/commands/bugCommand.ts
 init_dist2();
@@ -127679,6 +127916,7 @@ async function runNonInteractive(config, input, prompt_id) {
         abortController.signal,
         prompt_id
       );
+      let hasFinishedEvent = false;
       for await (const event of responseStream) {
         if (abortController.signal.aborted) {
           console.error("Operation cancelled.");
@@ -127694,6 +127932,8 @@ async function runNonInteractive(config, input, prompt_id) {
             id: toolCallRequest.callId
           };
           functionCalls.push(fc);
+        } else if (event.type === GeminiEventType.Finished) {
+          hasFinishedEvent = true;
         }
       }
       if (functionCalls.length > 0) {
@@ -127729,6 +127969,9 @@ async function runNonInteractive(config, input, prompt_id) {
           }
         }
         currentMessages = [{ role: "user", parts: toolResponseParts }];
+      } else if (hasFinishedEvent) {
+        process.stdout.write("\n");
+        return;
       } else {
         process.stdout.write("\n");
         return;

package/package.json

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