@zythum02/fello-server 0.1.39 → 0.1.45

package/out/scripts/worker-file-outline/worker.mjs

@@ -1,5 +1,113 @@
 import { existsSync, readFileSync } from "fs";
 import { Parser, Language } from "web-tree-sitter";
+const DEFAULT_DETAIL_LABELS = /* @__PURE__ */ new Set(["import", "import from", "export"]);
+function stripQuotes(text) {
+  return text.replace(/^['"`]|['"`]$/g, "");
+}
+function findNestedString(cursor, sourceTypes) {
+  if (!cursor.gotoFirstChild()) return "";
+  let found = "";
+  do {
+    const type = cursor.nodeType;
+    if (type === "string" || type === "string_literal" || type === "interpreted_string_literal") {
+      found = stripQuotes(cursor.nodeText);
+      break;
+    }
+    if (sourceTypes.has(type)) {
+      found = findNestedString(cursor, sourceTypes);
+      if (found) break;
+    }
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+  return found;
+}
+function extractImportExportDetail(cursor, nodeText, label, config) {
+  const sourceFields = new Set(config.sourceFields || []);
+  const sourceTypes = new Set(config.sourceTypes || []);
+  const clauseTypes = new Set(config.clauseTypes || []);
+  const typeKeywordTypes = new Set(config.typeKeywordTypes || []);
+  let source = "";
+  let clauses = [];
+  let hasTypeKeyword = false;
+  if (!cursor.gotoFirstChild()) {
+    return { name: nodeText.trim() };
+  }
+  do {
+    const field = cursor.currentFieldName;
+    const type = cursor.nodeType;
+    const text = cursor.nodeText;
+    if (field && sourceFields.has(field)) {
+      source = stripQuotes(text);
+    } else if (sourceTypes.has(type)) {
+      if (!source) {
+        if (type === "string" || type === "string_literal" || type === "interpreted_string_literal") {
+          source = stripQuotes(text);
+        } else {
+          const nested = findNestedString(cursor, sourceTypes);
+          source = nested || stripQuotes(text);
+        }
+      }
+    } else if (clauseTypes.has(type)) {
+      clauses.push(text);
+    } else if (typeKeywordTypes.has(type)) {
+      hasTypeKeyword = true;
+    }
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+  if (!source && config.clausesAsSource && clauses.length > 0) {
+    source = clauses.join(", ");
+    clauses = [];
+  }
+  if (!source && config.textFallbackPattern) {
+    const match = nodeText.match(new RegExp(config.textFallbackPattern));
+    if (match) {
+      source = match[1] || "";
+      if (match[2]) clauses = [match[2].trim()];
+    }
+  }
+  let detail;
+  if (clauses.length > 0) {
+    const clauseText = clauses.join(", ").replace(/\s*\n\s*/g, " ").replace(/\s{2,}/g, " ");
+    detail = hasTypeKeyword && !clauseText.startsWith("type") ? `type ${clauseText}` : clauseText;
+  }
+  if (!source && config.detailAsNameWhenNoSource) {
+    const keyword = label.split(" ")[0];
+    const pattern = new RegExp(`^${keyword}\\s*`);
+    let firstLine = nodeText.split("\n")[0].replace(pattern, "").trim();
+    if (config.trimPatterns) {
+      for (const tp of config.trimPatterns) {
+        firstLine = firstLine.replace(new RegExp(tp), "").trim();
+      }
+    }
+    return { name: detail || firstLine, detail: void 0 };
+  }
+  if (!source) {
+    const keyword = label.split(" ")[0];
+    const pattern = new RegExp(`^${keyword}\\s+`);
+    let firstLine = nodeText.split("\n")[0].replace(pattern, "").trim();
+    if (config.trimPatterns) {
+      for (const tp of config.trimPatterns) {
+        firstLine = firstLine.replace(new RegExp(tp), "").trim();
+      }
+    }
+    const cleanDetail = detail && firstLine.includes(detail) ? void 0 : detail;
+    return { name: firstLine, detail: cleanDetail };
+  }
+  return { name: source, detail };
+}
+function resolveLabel(cursor, sym) {
+  if (!sym.labelByChild) return sym.label;
+  if (!cursor.gotoFirstChild()) return sym.label;
+  let resolved;
+  do {
+    const childType = cursor.nodeType;
+    const childText = cursor.nodeText.trim();
+    resolved = sym.labelByChild[childType] ?? sym.labelByChild[childText];
+    if (resolved) break;
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+  return resolved ?? sym.label;
+}
 function scanName(cursor, nameOf) {
   if (!cursor.gotoFirstChild()) return "";
   const idTypes = new Set(nameOf.identifierTypes || []);
@@ -21,21 +129,26 @@ function scanName(cursor, nameOf) {
     if (!name && recTypes.has(t)) {
       name = scanName(cursor, nameOf);
     }
-    if (!name && idTypes.has(t)) {
-      if (t !== "type_identifier" || cursor.currentFieldName !== "type") {
-        name = cursor.nodeText;
-      }
+  } while (!name && cursor.gotoNextSibling());
+  if (!name) {
+    cursor.gotoParent();
+    if (!cursor.gotoFirstChild()) {
+      return "";
     }
-  } while (cursor.gotoNextSibling());
+    do {
+      const t = cursor.nodeType;
+      if (idTypes.has(t)) {
+        if (t !== "type_identifier" || cursor.currentFieldName !== "type") {
+          name = cursor.nodeText;
+          break;
+        }
+      }
+    } while (cursor.gotoNextSibling());
+  }
   cursor.gotoParent();
   return name;
 }
-function isPythonDocstring(cursor) {
-  if (cursor.nodeType !== "expression_statement") return false;
-  const text = cursor.nodeText.trim();
-  return text.startsWith('"""') || text.startsWith("'''");
-}
-function collectComments(tree) {
+function collectComments(tree, docstrings) {
   const comments = [];
   const cursor = tree.walk();
   let descend = true;
@@ -43,7 +156,19 @@ function collectComments(tree) {
     while (true) {
       if (cursor.currentDepth < 0) break;
       const t = cursor.nodeType;
-      if (t === "comment" || t === "line_comment" || t === "multiline_comment" || isPythonDocstring(cursor)) {
+      let isComment = t === "comment" || t === "line_comment" || t === "multiline_comment" || t === "documentation_comment";
+      if (!isComment && docstrings) {
+        for (const ds of docstrings) {
+          if (t === ds.nodeType) {
+            const text = cursor.nodeText.trim();
+            if (ds.prefixes.some((p) => text.startsWith(p))) {
+              isComment = true;
+              break;
+            }
+          }
+        }
+      }
+      if (isComment) {
         comments.push({
           text: cursor.nodeText.trim(),
           startLine: cursor.startPosition.row + 1,
@@ -67,20 +192,20 @@ function collectComments(tree) {
   return comments;
 }
 function cleanComment(text) {
-  let cleaned = text.replace(/^\/\*\*?/, "").replace(/\*\/$/, "").replace(/^\s*\* ?/gm, "").replace(/^\/+/, "").replace(/^#/, "").replace(/^'''/, "").replace(/'''$/, "").replace(/^"""/, "").replace(/"""$/, "").trim();
+  let cleaned = text.replace(/^\/\*\*?/, "").replace(/\*\/$/, "").replace(/^\s*\* ?/gm, "").replace(/^\s*\/\/\/? ?/gm, "").replace(/^#/, "").replace(/^'''/, "").replace(/'''$/, "").replace(/^"""/, "").replace(/"""$/, "").trim();
   const lines = cleaned.split("\n").map((l) => l.trim()).filter(Boolean);
   return lines.length > 0 ? lines[0] : "";
 }
 function attachComments(symbols, comments) {
   let ci = 0;
   for (const sym of symbols) {
-    if (sym.depth > 0) continue;
     while (ci < comments.length && comments[ci].endLine < sym.startLine - 2) ci++;
     if (ci < comments.length) {
       const c = comments[ci];
       const gap = sym.startLine - c.endLine;
       if (gap === 1 || gap === 2) {
         sym.comment = cleanComment(c.text);
+        ci++;
         continue;
       }
     }
@@ -102,11 +227,13 @@ async function parse(req) {
   const parser = new Parser();
   parser.setLanguage(lang);
   const source = readFileSync(req.filePath, "utf8");
-  const totalLines = source.split("\n").length;
+  const totalLines = source.endsWith("\n") ? source.split("\n").length - 1 : source.split("\n").length;
   const tree = parser.parse(source);
   if (!tree) throw new Error("Failed to parse");
   let result = [];
   const typeSet = new Set(req.symbols.flatMap((s) => s.types));
+  const symbolScanBoundaryTypes = new Set(req.symbolScanBoundaryTypes || []);
+  const detailLabels = req.statementDetail ? new Set(req.statementDetail.labels || DEFAULT_DETAIL_LABELS) : null;
   const cursor = tree.walk();
   try {
     let descend = true, declDepth = -1;
@@ -119,19 +246,54 @@ async function parse(req) {
       if (descend && isDecl) {
         for (const sym of req.symbols) {
           if (sym.types.includes(t) && (sym.maxDepth === void 0 || declDepth <= sym.maxDepth)) {
+            const kind = resolveLabel(cursor, sym);
             let name = "";
-            if (sym.hasName) name = scanName(cursor, req.nameOf);
+            let detail;
+            let useContentEndLine = false;
+            if (sym.hasName) {
+              if (detailLabels?.has(kind)) {
+                const info = extractImportExportDetail(
+                  cursor,
+                  cursor.nodeText,
+                  kind,
+                  req.statementDetail
+                );
+                name = info.name;
+                detail = info.detail;
+                useContentEndLine = true;
+              } else {
+                name = scanName(cursor, req.nameOf);
+              }
+            }
+            const startLine = cursor.startPosition.row + 1;
+            let endLine;
+            if (useContentEndLine) {
+              const lines = cursor.nodeText.split("\n");
+              let count = 0;
+              for (const line of lines) {
+                if (line.trim() === "") break;
+                count++;
+              }
+              endLine = startLine + Math.max(count, 1) - 1;
+            } else {
+              endLine = cursor.endPosition.row + 1;
+            }
             result.push({
-              kind: sym.label,
-              name: sym.hasName ? name || `(anonymous ${sym.label})` : "",
-              startLine: cursor.startPosition.row + 1,
-              endLine: cursor.endPosition.row + 1,
-              depth: declDepth
+              kind,
+              name: sym.hasName ? name || `(anonymous ${kind})` : "",
+              startLine,
+              endLine,
+              depth: declDepth,
+              ...detail ? { detail } : {}
             });
             break;
           }
         }
       }
+      if (descend && symbolScanBoundaryTypes.has(t)) {
+        descend = false;
+        continue;
+      }
       if (descend && cursor.gotoFirstChild()) continue;
       if (cursor.gotoNextSibling()) {
         descend = true;
@@ -156,6 +318,13 @@ async function parse(req) {
               const wStart = wCursor.startPosition.row + 1;
               const wEnd = wCursor.endPosition.row + 1;
               const maxDepth = wrapper.maxDepth ?? Infinity;
+              let effectivePrefix = wrapper.prefix;
+              const wNodeFirstLine = wCursor.nodeText.split("\n")[0];
+              const prefixKeyword = wrapper.prefix.trim();
+              const afterKeyword = wNodeFirstLine.slice(wNodeFirstLine.indexOf(prefixKeyword) + prefixKeyword.length).trimStart();
+              if (afterKeyword.startsWith("default ") || afterKeyword.startsWith("default\n")) {
+                effectivePrefix = wrapper.prefix + "default ";
+              }
               const covered = result.some(
                 (r) => r.startLine >= wStart && r.endLine <= wEnd && r.depth <= maxDepth
               );
@@ -169,28 +338,73 @@ async function parse(req) {
                       r.depth = 1;
                       continue;
                     }
-                    if (r.kind.startsWith(wrapper.prefix)) continue;
+                    if (r.kind.startsWith(effectivePrefix)) continue;
                     let inserted = false;
                     for (const existing of appliedPrefixes) {
                       if (r.kind.startsWith(existing)) {
-                        r.kind = existing + wrapper.prefix + r.kind.slice(existing.length);
+                        r.kind = existing + effectivePrefix + r.kind.slice(existing.length);
                         inserted = true;
                         break;
                       }
                     }
                     if (!inserted) {
-                      r.kind = wrapper.prefix + r.kind;
+                      r.kind = effectivePrefix + r.kind;
                     }
                   }
                 }
+                if (wrapper.createContainerWhenCovered && wrapper.createStandaloneLabel) {
+                  const label = wrapper.createStandaloneLabel;
+                  let containerName;
+                  let containerDetail;
+                  if (detailLabels?.has(label)) {
+                    const info = extractImportExportDetail(
+                      wCursor,
+                      wCursor.nodeText,
+                      label,
+                      req.statementDetail
+                    );
+                    containerName = info.name;
+                    containerDetail = info.detail;
+                  } else {
+                    containerName = scanName(wCursor, req.nameOf);
+                  }
+                  for (const r of result) {
+                    if (r.startLine >= wStart && r.endLine <= wEnd) {
+                      r.depth++;
+                    }
+                  }
+                  result.push({
+                    kind: label,
+                    name: containerName || "{...}",
+                    startLine: wStart,
+                    endLine: wEnd,
+                    depth: 0,
+                    ...containerDetail ? { detail: containerDetail } : {}
+                  });
+                }
               } else if (wrapper.createStandaloneLabel) {
-                const exportName = scanName(wCursor, req.nameOf);
+                const label = wrapper.createStandaloneLabel;
+                let exportName;
+                let exportDetail;
+                if (detailLabels?.has(label)) {
+                  const info = extractImportExportDetail(
+                    wCursor,
+                    wCursor.nodeText,
+                    label,
+                    req.statementDetail
+                  );
+                  exportName = info.name;
+                  exportDetail = info.detail;
+                } else {
+                  exportName = scanName(wCursor, req.nameOf);
+                }
                 result.push({
-                  kind: wrapper.createStandaloneLabel,
+                  kind: label,
                   name: exportName || "{...}",
                   startLine: wStart,
                   endLine: wEnd,
-                  depth: 0
+                  depth: 0,
+                  ...exportDetail ? { detail: exportDetail } : {}
                 });
               }
             }
@@ -212,7 +426,7 @@ async function parse(req) {
       }
     }
     result.sort((a, b) => a.startLine - b.startLine);
-    const comments = collectComments(tree);
+    const comments = collectComments(tree, req.docstrings);
     attachComments(result, comments);
     return { symbols: result, totalLines };
   } finally {