@rooode/dsh-plugin-preview 0.1.4 → 0.1.5

package/cordis.patch.yml

@@ -13,4 +13,16 @@
           - .json
           - .yaml
           - .yml
+          - .js
+          - .ts
+          - .java
+          - .cpp
+          - .c
+          - .h
+          - .hpp
+          - .py
+          - .go
+          - .rs
+          - .sh
+          - .sql
         maxFileSizeMb: 10

package/lib/client.js

@@ -33,8 +33,13 @@
     const SUPPORTED_EXTENSIONS = new Set([
       '.md', '.markdown', '.mdown', '.mkdn', '.mdwn',
       '.txt', '.log', '.json', '.yaml', '.yml',
-      '.js', '.jsx', '.ts', '.tsx', '.html', '.css', '.scss',
-      '.py', '.sh', '.bash', '.ps1', '.sql', '.toml', '.xml'
+      '.js', '.jsx', '.ts', '.tsx', '.html', '.css', '.scss', '.less',
+      '.java', '.jav', '.jsp',
+      '.cpp', '.c', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.inl',
+      '.py', '.pyw', '.ipynb',
+      '.go', '.rs', '.cs', '.kt',
+      '.sh', '.bash', '.zsh', '.ps1', '.bat', '.cmd',
+      '.sql', '.toml', '.xml', '.svg', '.ini', '.env', '.properties'
     ]);
 
     // =========================================================================
@@ -172,8 +177,15 @@
       if (ext === '.yaml' || ext === '.yml' || ext === '.toml' || ext === '.ini') return { icon: '⚙️', color: '#f97316' };
       if (ext === '.html' || ext === '.htm') return { icon: '🌐', color: '#ef4444' };
       if (ext === '.css' || ext === '.scss' || ext === '.less') return { icon: '#', color: '#06b6d4' };
-      if (ext === '.py') return { icon: '🐍', color: '#38bdf8' };
-      if (ext === '.sh' || ext === '.bash' || ext === '.ps1') return { icon: '⌨️', color: '#8b5cf6' };
+      if (ext === '.java' || ext === '.jav') return { icon: '☕', color: '#ea580c' };
+      if (['.cpp', '.cc', '.cxx', '.hpp', '.hxx'].includes(ext)) return { icon: 'C++', color: '#0284c7' };
+      if (ext === '.c' || ext === '.h') return { icon: 'C', color: '#64748b' };
+      if (ext === '.py' || ext === '.pyw') return { icon: '🐍', color: '#38bdf8' };
+      if (ext === '.go') return { icon: 'GO', color: '#00add8' };
+      if (ext === '.rs') return { icon: '🦀', color: '#ea580c' };
+      if (ext === '.cs') return { icon: 'C#', color: '#a855f7' };
+      if (ext === '.kt') return { icon: 'KT', color: '#7c3aed' };
+      if (ext === '.sh' || ext === '.bash' || ext === '.ps1' || ext === '.zsh') return { icon: '⌨️', color: '#8b5cf6' };
       if (['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp'].includes(ext)) return { icon: '🖼️', color: '#ec4899' };
       if (ext === '.log' || ext === '.txt') return { icon: '📄', color: '#64748b' };
       return { icon: '📄', color: '#94a3b8' };
@@ -187,7 +199,12 @@
       if (['.json', '.jsonc', '.json5', '.geojson', '.lock'].includes(ext)) return 'json';
       if (['.yaml', '.yml'].includes(ext)) return 'yaml';
       if (['.js', '.jsx', '.mjs', '.cjs', '.ts', '.tsx', '.mts', '.cts'].includes(ext)) return 'javascript';
-      if (['.py', '.pyw'].includes(ext)) return 'python';
+      if (['.java', '.jav', '.jsp'].includes(ext)) return 'java';
+      if (['.cpp', '.c', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.inl'].includes(ext)) return 'cpp';
+      if (['.py', '.pyw', '.ipynb'].includes(ext)) return 'python';
+      if (['.go'].includes(ext)) return 'go';
+      if (['.rs'].includes(ext)) return 'rust';
+      if (['.cs'].includes(ext)) return 'csharp';
       if (['.html', '.htm', '.svg', '.xml'].includes(ext)) return 'markup';
       if (['.css', '.scss', '.less', '.sass'].includes(ext)) return 'css';
       if (['.sh', '.bash', '.zsh', '.ps1', '.bat', '.cmd'].includes(ext)) return 'shell';
@@ -1239,19 +1256,172 @@
       return out;
     }
 
+    function highlightJava(code) {
+      if (!code) return '';
+      const keywords = new Set([
+        'public', 'private', 'protected', 'class', 'interface', 'enum', 'record', 'extends',
+        'implements', 'static', 'final', 'abstract', 'void', 'return', 'if', 'else', 'for',
+        'while', 'do', 'switch', 'case', 'break', 'continue', 'default', 'new', 'this', 'super',
+        'try', 'catch', 'finally', 'throw', 'throws', 'import', 'package', 'synchronized',
+        'volatile', 'transient', 'native', 'strictfp', 'instanceof', 'assert', 'yield', 'sealed',
+        'permits', 'var', 'const', 'goto'
+      ]);
+      const types = new Set([
+        'int', 'long', 'short', 'byte', 'float', 'double', 'boolean', 'char', 'void',
+        'String', 'Object', 'Integer', 'Long', 'Boolean', 'Double', 'Float', 'Byte', 'Short', 'Character',
+        'List', 'Map', 'Set', 'ArrayList', 'HashMap', 'HashSet', 'LinkedList', 'TreeMap', 'TreeSet',
+        'Optional', 'Stream', 'Arrays', 'Collections', 'System', 'Thread', 'Exception', 'RuntimeException',
+        'Throwable', 'Error', 'Class', 'StringBuilder', 'StringBuffer', 'CompletableFuture', 'Future',
+        'null', 'true', 'false'
+      ]);
+
+      const tokenRegex = /(\/\*[\s\S]*?\*\/|\/\/.*$|"""[\s\S]*?"""|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|@[a-zA-Z0-9_.]+|\b(?:0x[0-9a-fA-F]+|\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?[fFdDlL]?)\b|\b[a-zA-Z_$][a-zA-Z0-9_$]*\b|->|::|==|!=|<=|>=|&&|\|\||\+\+|--|\+=|-=|\*=|\/=|%=|&=|\|=|\^=|>>>=|>>=|<<=|[+\-*/%=!&|^~<>?:;,{}()\[\].])/gm;
+
+      let lastIndex = 0;
+      let out = '';
+      let match;
+
+      while ((match = tokenRegex.exec(code)) !== null) {
+        const raw = match[0];
+        const index = match.index;
+        if (index > lastIndex) {
+          out += escapeHtml(code.slice(lastIndex, index));
+        }
+        lastIndex = tokenRegex.lastIndex;
+
+        if (raw.startsWith('/*') || raw.startsWith('//')) {
+          out += '<span class="tok-comment">' + escapeHtml(raw) + '</span>';
+        } else if (raw.startsWith('"""') || raw.startsWith('"') || raw.startsWith("'")) {
+          out += '<span class="tok-string">' + escapeHtml(raw) + '</span>';
+        } else if (raw.startsWith('@')) {
+          out += '<span class="tok-attr">' + escapeHtml(raw) + '</span>';
+        } else if (/^\d|^0x/.test(raw)) {
+          out += '<span class="tok-number">' + escapeHtml(raw) + '</span>';
+        } else if (/^[a-zA-Z_$]/.test(raw)) {
+          if (keywords.has(raw)) {
+            out += '<span class="tok-keyword">' + escapeHtml(raw) + '</span>';
+          } else if (types.has(raw)) {
+            out += '<span class="tok-type">' + escapeHtml(raw) + '</span>';
+          } else {
+            const remainder = code.slice(lastIndex);
+            if (/^\s*\(/.test(remainder)) {
+              out += '<span class="tok-func">' + escapeHtml(raw) + '</span>';
+            } else {
+              out += escapeHtml(raw);
+            }
+          }
+        } else if (/^(->|::|==|!=|<=|>=|&&|\|\||\+\+|--|\+=|-=|\*=|\/=|%=|&=|\|=|\^=|>>>=|>>=|<<=|[+\-*/%=!&|^~<>])$/.test(raw)) {
+          out += '<span class="tok-operator">' + escapeHtml(raw) + '</span>';
+        } else if (/^[{}()\[\]]$/.test(raw)) {
+          out += '<span class="tok-bracket">' + escapeHtml(raw) + '</span>';
+        } else if (/^[,;:?]$/.test(raw)) {
+          out += '<span class="tok-punctuation">' + escapeHtml(raw) + '</span>';
+        } else {
+          out += escapeHtml(raw);
+        }
+      }
+
+      if (lastIndex < code.length) {
+        out += escapeHtml(code.slice(lastIndex));
+      }
+      return out;
+    }
+
+    function highlightCpp(code) {
+      if (!code) return '';
+      const keywords = new Set([
+        'class', 'struct', 'union', 'enum', 'template', 'typename', 'namespace', 'using',
+        'typedef', 'public', 'private', 'protected', 'virtual', 'override', 'final', 'const',
+        'constexpr', 'consteval', 'constinit', 'static', 'inline', 'auto', 'void', 'return',
+        'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue', 'default',
+        'new', 'delete', 'this', 'try', 'catch', 'throw', 'noexcept', 'explicit', 'friend',
+        'mutable', 'volatile', 'concept', 'requires', 'co_await', 'co_yield', 'co_return',
+        'decltype', 'sizeof', 'alignas', 'alignof', 'static_cast', 'dynamic_cast',
+        'reinterpret_cast', 'const_cast', 'operator', 'export', 'import', 'module'
+      ]);
+      const types = new Set([
+        'int', 'long', 'short', 'char', 'float', 'double', 'bool', 'void', 'wchar_t', 'char8_t',
+        'char16_t', 'char32_t', 'size_t', 'int8_t', 'int16_t', 'int32_t', 'int64_t',
+        'uint8_t', 'uint16_t', 'uint32_t', 'uint64_t', 'nullptr', 'true', 'false',
+        'string', 'wstring', 'vector', 'map', 'unordered_map', 'set', 'unordered_set',
+        'pair', 'tuple', 'unique_ptr', 'shared_ptr', 'weak_ptr', 'make_unique', 'make_shared',
+        'std', 'cout', 'cin', 'cerr', 'endl', 'array', 'deque', 'list', 'queue', 'stack'
+      ]);
+
+      const tokenRegex = /(\/\*[\s\S]*?\*\/|\/\/.*$|#(?:include|define|ifdef|ifndef|endif|if|else|elif|pragma|undef|error)\b.*$|R"\(.*?\)"|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\b(?:0x[0-9a-fA-F]+|\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?[uUlLfF]?)\b|\b[a-zA-Z_][a-zA-Z0-9_]*\b|::|->\*|->|==|!=|<=|>=|<=>|&&|\|\||\+\+|--|\+=|-=|\*=|\/=|%=|&=|\|=|\^=|>>=|<<=|<<|>>|[+\-*/%=!&|^~<>?:;,{}()\[\].])/gm;
+
+      let lastIndex = 0;
+      let out = '';
+      let match;
+
+      while ((match = tokenRegex.exec(code)) !== null) {
+        const raw = match[0];
+        const index = match.index;
+        if (index > lastIndex) {
+          out += escapeHtml(code.slice(lastIndex, index));
+        }
+        lastIndex = tokenRegex.lastIndex;
+
+        if (raw.startsWith('/*') || raw.startsWith('//')) {
+          out += '<span class="tok-comment">' + escapeHtml(raw) + '</span>';
+        } else if (raw.startsWith('#')) {
+          const spaceIdx = raw.indexOf(' ');
+          if (spaceIdx !== -1) {
+            const dir = raw.slice(0, spaceIdx);
+            const rest = raw.slice(spaceIdx);
+            out += '<span class="tok-keyword">' + escapeHtml(dir) + '</span><span class="tok-string">' + escapeHtml(rest) + '</span>';
+          } else {
+            out += '<span class="tok-keyword">' + escapeHtml(raw) + '</span>';
+          }
+        } else if (raw.startsWith('R"') || raw.startsWith('"') || raw.startsWith("'")) {
+          out += '<span class="tok-string">' + escapeHtml(raw) + '</span>';
+        } else if (/^\d|^0x/.test(raw)) {
+          out += '<span class="tok-number">' + escapeHtml(raw) + '</span>';
+        } else if (/^[a-zA-Z_]/.test(raw)) {
+          if (keywords.has(raw)) {
+            out += '<span class="tok-keyword">' + escapeHtml(raw) + '</span>';
+          } else if (types.has(raw)) {
+            out += '<span class="tok-type">' + escapeHtml(raw) + '</span>';
+          } else {
+            const remainder = code.slice(lastIndex);
+            if (/^\s*\(/.test(remainder)) {
+              out += '<span class="tok-func">' + escapeHtml(raw) + '</span>';
+            } else {
+              out += escapeHtml(raw);
+            }
+          }
+        } else if (/^(::|->\*|->|==|!=|<=|>=|<=>|&&|\|\||\+\+|--|\+=|-=|\*=|\/=|%=|&=|\|=|\^=|>>=|<<=|<<|>>|[+\-*/%=!&|^~<>])$/.test(raw)) {
+          out += '<span class="tok-operator">' + escapeHtml(raw) + '</span>';
+        } else if (/^[{}()\[\]]$/.test(raw)) {
+          out += '<span class="tok-bracket">' + escapeHtml(raw) + '</span>';
+        } else if (/^[,;:?]$/.test(raw)) {
+          out += '<span class="tok-punctuation">' + escapeHtml(raw) + '</span>';
+        } else {
+          out += escapeHtml(raw);
+        }
+      }
+
+      if (lastIndex < code.length) {
+        out += escapeHtml(code.slice(lastIndex));
+      }
+      return out;
+    }
+
     function highlightPython(code) {
       if (!code) return '';
       const pyKeywords = new Set([
         'def', 'class', 'import', 'from', 'return', 'if', 'elif', 'else', 'for', 'while',
         'try', 'except', 'finally', 'raise', 'with', 'as', 'lambda', 'pass', 'yield',
-        'async', 'await', 'global', 'nonlocal', 'assert', 'del', 'in', 'is', 'not', 'and', 'or'
+        'async', 'await', 'global', 'nonlocal', 'assert', 'del', 'in', 'is', 'not', 'and', 'or',
+        'match', 'case'
       ]);
       const pyBuiltins = new Set([
         'True', 'False', 'None', 'self', 'cls', 'print', 'len', 'range', 'dict', 'list',
-        'set', 'tuple', 'str', 'int', 'float', 'bool', 'type', 'isinstance', 'enumerate', 'zip'
+        'set', 'tuple', 'str', 'int', 'float', 'bool', 'type', 'isinstance', 'enumerate', 'zip',
+        'super', 'sum', 'min', 'max', 'any', 'all', 'open', 'map', 'filter'
       ]);
 
-      const tokenRegex = /("""[\s\S]*?"""|'''[\s\S]*?'''|#.*$|f?"(?:\\[\s\S]|[^"\\])*"|f?'(?:\\[\s\S]|[^'\\])*'|\b\d+(?:\.\d+)?\b|\b[a-zA-Z_][a-zA-Z0-9_]*\b|==|!=|<=|>=|\+=|-=|\*=|\/=|->|[+\-*/%=&|^~<>?:;,{}()\[\].])/gm;
+      const tokenRegex = /("""[\s\S]*?"""|'''[\s\S]*?'''|#.*$|@[a-zA-Z0-9_.]+|f?"(?:\\[\s\S]|[^"\\])*"|f?'(?:\\[\s\S]|[^'\\])*'|\b\d+(?:\.\d+)?\b|\b[a-zA-Z_][a-zA-Z0-9_]*\b|==|!=|<=|>=|\+=|-=|\*=|\/=|->|[+\-*/%=&|^~<>?:;,{}()\[\].])/gm;
 
       let lastIndex = 0;
       let out = '';
@@ -1269,6 +1439,8 @@
           out += '<span class="tok-comment">' + escapeHtml(raw) + '</span>';
         } else if (raw.startsWith('"""') || raw.startsWith("'''") || raw.startsWith('"') || raw.startsWith("'") || raw.startsWith('f"') || raw.startsWith("f'")) {
           out += '<span class="tok-string">' + escapeHtml(raw) + '</span>';
+        } else if (raw.startsWith('@')) {
+          out += '<span class="tok-attr">' + escapeHtml(raw) + '</span>';
         } else if (/^\d/.test(raw)) {
           out += '<span class="tok-number">' + escapeHtml(raw) + '</span>';
         } else if (/^[a-zA-Z_]/.test(raw)) {
@@ -1347,6 +1519,22 @@
           .replace(/(--.*$)/gm, '<span class="tok-comment">$1</span>')
           .replace(/('[^']*')/g, '<span class="tok-string">$1</span>');
       }
+      if (category === 'go') {
+        const goKeywords = /\b(package|import|func|return|var|const|type|struct|interface|map|chan|go|defer|if|else|for|range|switch|case|default|select|break|continue|fallthrough)\b/g;
+        return escapeHtml(code)
+          .replace(/(\b(?:string|int|int64|int32|uint|uint64|byte|rune|bool|float32|float64|error|nil|true|false)\b)/g, '<span class="tok-type">$1</span>')
+          .replace(goKeywords, '<span class="tok-keyword">$1</span>')
+          .replace(/(\/\/.*$)/gm, '<span class="tok-comment">$1</span>')
+          .replace(/("(?:\\[\s\S]|[^"\\])*")/g, '<span class="tok-string">$1</span>');
+      }
+      if (category === 'rust') {
+        const rsKeywords = /\b(fn|let|mut|pub|struct|enum|impl|trait|type|use|mod|crate|return|if|else|match|loop|while|for|in|break|continue|async|await|where|unsafe|as|ref|move)\b/g;
+        return escapeHtml(code)
+          .replace(/(\b(?:i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize|f32|f64|bool|char|str|String|Vec|Option|Result|Some|None|Ok|Err|true|false)\b)/g, '<span class="tok-type">$1</span>')
+          .replace(rsKeywords, '<span class="tok-keyword">$1</span>')
+          .replace(/(\/\/.*$)/gm, '<span class="tok-comment">$1</span>')
+          .replace(/("(?:\\[\s\S]|[^"\\])*")/g, '<span class="tok-string">$1</span>');
+      }
       const lines = code.split('\n');
       return lines.map(line => {
         const commentIdx = line.indexOf('#');
@@ -1371,10 +1559,12 @@
       if (category === 'json') return highlightJSON(rawCode);
       if (category === 'yaml') return highlightYAML(rawCode);
       if (category === 'javascript') return highlightJS(rawCode);
+      if (category === 'java') return highlightJava(rawCode);
+      if (category === 'cpp') return highlightCpp(rawCode);
       if (category === 'python') return highlightPython(rawCode);
       if (category === 'markup') return highlightHTML(rawCode);
       if (category === 'css') return highlightCSS(rawCode);
-      if (category === 'shell' || category === 'config' || category === 'sql') return highlightGenericCode(rawCode, category);
+      if (category === 'shell' || category === 'config' || category === 'sql' || category === 'go' || category === 'rust' || category === 'csharp') return highlightGenericCode(rawCode, category);
       return escapeHtml(rawCode);
     }
 
@@ -1504,7 +1694,7 @@
         lines.forEach((line, idx) => {
           const lineNum = idx + 1;
           const trimmed = line.trim();
-          if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*')) return;
+          if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*') || trimmed.startsWith('return ')) return;
 
           const classMatch = trimmed.match(/\bclass\s+([a-zA-Z0-9_$]+)/);
           if (classMatch) {
@@ -1534,15 +1724,68 @@
             symbols.push({ id: `line-${lineNum}`, name: 'default export', kind: 'export', line: lineNum, text: `📦 export default` });
           }
         });
+      } else if (category === 'java') {
+        lines.forEach((line, idx) => {
+          const lineNum = idx + 1;
+          const trimmed = line.trim();
+          if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*') || trimmed.startsWith('throw ') || trimmed.startsWith('return ')) return;
+
+          const pkgMatch = trimmed.match(/^package\s+([a-zA-Z0-9_.]+);/);
+          if (pkgMatch) {
+            symbols.push({ id: `line-${lineNum}`, name: pkgMatch[1], kind: 'package', line: lineNum, text: `📦 package ${pkgMatch[1]}` });
+            return;
+          }
+
+          const classMatch = trimmed.match(/\b(?:public|protected|private|static|final|abstract\s+)*(class|interface|enum|record)\s+([a-zA-Z0-9_]+)/);
+          if (classMatch) {
+            const typeIcon = classMatch[1] === 'interface' ? '🏷️' : classMatch[1] === 'enum' ? '🔢' : '🔷';
+            symbols.push({ id: `line-${lineNum}`, name: classMatch[2], kind: classMatch[1], line: lineNum, text: `${typeIcon} ${classMatch[1]} ${classMatch[2]}` });
+            return;
+          }
+
+          const methodMatch = trimmed.match(/^(?:@\w+\s+)*(?:public|protected|private|static|final|synchronized|abstract|default|native|\s)*(?:<[^>]+>\s+)?([a-zA-Z0-9_<>[],.\s]+(?:\s*\[\s*\])?\s+)?([a-zA-Z0-9_]+)\s*\([^)]*\)\s*(?:throws\s+[a-zA-Z0-9_,\s]+)?\s*\{?$/);
+          if (methodMatch) {
+            const name = methodMatch[2];
+            if (!['if', 'for', 'while', 'switch', 'catch', 'return', 'throw', 'new', 'this', 'super'].includes(name)) {
+              symbols.push({ id: `line-${lineNum}`, name, kind: 'method', line: lineNum, text: `⚡ ${name}()` });
+            }
+          }
+        });
+      } else if (category === 'cpp') {
+        lines.forEach((line, idx) => {
+          const lineNum = idx + 1;
+          const trimmed = line.trim();
+          if (trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*') || trimmed.startsWith('#') || trimmed.startsWith('throw ') || trimmed.startsWith('return ')) return;
+
+          const nsMatch = trimmed.match(/^namespace\s+([a-zA-Z0-9_:]+)/);
+          if (nsMatch) {
+            symbols.push({ id: `line-${lineNum}`, name: nsMatch[1], kind: 'namespace', line: lineNum, text: `📦 namespace ${nsMatch[1]}` });
+            return;
+          }
+
+          const classMatch = trimmed.match(/\b(class|struct|union|enum\s+class|enum)\s+([a-zA-Z0-9_]+)/);
+          if (classMatch && !trimmed.endsWith(';')) {
+            symbols.push({ id: `line-${lineNum}`, name: classMatch[2], kind: classMatch[1], line: lineNum, text: `🔷 ${classMatch[1]} ${classMatch[2]}` });
+            return;
+          }
+
+          const funcMatch = trimmed.match(/^(?:(?:inline|virtual|static|constexpr|const|explicit|friend|auto|[a-zA-Z0-9_:<>&*~]+)\s+)+([a-zA-Z0-9_~]+)\s*\([^)]*\)\s*(?:const|noexcept|override|final|\s)*\s*\{?$/);
+          if (funcMatch && !['if', 'for', 'while', 'switch', 'catch', 'return', 'else', 'sizeof', 'decltype'].includes(funcMatch[1])) {
+            symbols.push({ id: `line-${lineNum}`, name: funcMatch[1], kind: 'function', line: lineNum, text: `⚡ fn ${funcMatch[1]}()` });
+          }
+        });
       } else if (category === 'python') {
         lines.forEach((line, idx) => {
           const lineNum = idx + 1;
-          const classMatch = line.match(/^class\s+([a-zA-Z0-9_]+)/);
+          const trimmed = line.trim();
+          if (trimmed.startsWith('#')) return;
+
+          const classMatch = trimmed.match(/^classs+([a-zA-Z0-9_]+)/);
           if (classMatch) {
             symbols.push({ id: `line-${lineNum}`, name: classMatch[1], kind: 'class', line: lineNum, text: `🔷 class ${classMatch[1]}` });
             return;
           }
-          const funcMatch = line.match(/^(\s*)(?:async\s+)?def\s+([a-zA-Z0-9_]+)/);
+          const funcMatch = line.match(/^(\s*)(?:async\s+)?defs+([a-zA-Z0-9_]+)/);
           if (funcMatch) {
             const prefix = funcMatch[1].length > 0 ? '  ' : '';
             symbols.push({ id: `line-${lineNum}`, name: funcMatch[2], kind: 'function', line: lineNum, text: `${prefix}⚡ def ${funcMatch[2]}()` });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rooode/dsh-plugin-preview",
-  "version": "0.1.4",
-  "description": "DeepSeek Harness Markdown 文档与工作空间文件浏览器右侧预览插件 (支持工作区文件树、JSON 交互结构树/格式化、YAML/JS/TS/Python 多语言语法高亮、代码符号大纲、自动换行与多标签 FileTabs)",
+  "version": "0.1.5",
+  "description": "DeepSeek Harness Markdown 文档与工作空间文件浏览器右侧预览插件 (支持工作区文件树、JSON 交互结构树/格式化、Java/C++/Python/JS/TS/YAML/Go/Rust 多语言语法高亮与符号大纲、自动换行与多标签 FileTabs)",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",