@rooode/dsh-plugin-preview 0.1.4 → 0.1.6

package/README.md

@@ -1,46 +1,54 @@
-# DeepSeek Harness - 右侧 Markdown 文档预览插件 (`@rooode/dsh-plugin-preview`)
+# DeepSeek Harness - 多功能文档与工作空间代码预览插件 (`@rooode/dsh-plugin-preview`)
 
 [![npm version](https://img.shields.io/npm/v/@rooode/dsh-plugin-preview.svg?style=flat-square)](https://www.npmjs.com/package/@rooode/dsh-plugin-preview)
 [![license](https://img.shields.io/npm/l/@rooode/dsh-plugin-preview.svg?style=flat-square)](https://github.com/rooode)
 
-本插件为 **DeepSeek Harness (DSH)** 与 **WorkBuddy** 对话界面提供了参考 WorkBuddy `FileTabs` 设计的**右侧多标签 Markdown 与文档预览面板**。
+本插件为 **DeepSeek Harness (DSH)** 与 **WorkBuddy** 对话界面提供了参考 WorkBuddy `FileTabs` 设计的**右侧多标签 Markdown、代码与工作空间文件树浏览器**。
 
-在 DSH 中，大模型经常会生成、改写或读取 `.md` 文档。默认情况下，点击生成的文档链接会直接调用 Windows 系统的本地记事本 (Notepad) 打开，打断了用户在 Web 会话中的阅读与操作体验。通过安装本插件，点击任何 Markdown 文档将直接在**右侧滑出多标签预览抽屉**，提供富文本渲染、目录大纲、源码分栏、一键复制、实时刷新以及按需本地打开等全套能力。
+在 DSH 中，大模型经常会生成、改写或读取 `.md` 文档与各类代码文件。默认情况下，点击生成的文档链接会直接调用 Windows 系统的本地记事本 (Notepad) 打开，打断了用户在 Web 会话中的阅读与操作体验。通过安装本插件，点击任何文档或代码将直接在**右侧滑出多标签预览抽屉**，提供工作空间目录树浏览、多语言代码高亮与符号大纲、JSON 交互结构树、GFM 富文本渲染、一键复制、实时刷新以及按需本地打开等全套能力。
 
 ---
 
 ## 🌟 核心特性 (Features)
 
-1. **自动拦截与无感打开**：
-   - 自动拦截对话底部 **产出文件行 (`ProducedFiles`)**、**工具执行行 (`ToolRow`)** 以及对话正文中的所有 `.md`、`.markdown`、`.txt`、`.json` 等文档点击。
-   - 不再弹出本地记事本，直接在右侧平滑滑出预览面板。
-
-2. **右侧多标签页支持 (FileTabs)**：
-   - 支持同时打开多个文档，标签栏清晰展示文件图标、文档名、修改标记与独立关闭按钮。
-   - 支持快速切换激活标签、一键全部关闭。
-   - 左侧边框支持 **鼠标自由拖拽调节宽度 (ResizeHandle)**（支持 380px 至 90vw 自由调整）。
-
-3. **全功能 GFM Markdown 渲染引擎**：
-   - **三模视图切换**：
-     - 📖 **渲染预览 (Preview)**：排版精美的富文本 Markdown 渲染。
-     - 📝 **源码模式 (Source)**：带行号与等宽字体的 Markdown 原文。
-     - 🌓 **分栏对比 (Split)**：左右双栏并排对照。
+1. **📁 工作空间目录树浏览器 (Workspace Tree Explorer)**：
+   - 树状层级展开/折叠项目所有目录与文件，支持文件大小与修改时间展示。
+   - 文件名即时过滤搜索，自动展开命中路径并折叠无关项。
+   - 快捷折叠全部目录、一键刷新磁盘目录结构。
+   - 目录树宽度支持鼠标自由拖拽调节。
+
+2. **💡 对话区智能交互与自动收起**：
+   - 当预览抽屉处于打开状态时，点击左侧会话列表或对话输入框，抽屉自动平滑收起/隐藏，保证专注对话输入。
+   - 收起后右下角保留胶囊浮窗，一键随时恢复展开。
+
+3. **🌳 交互式 JSON 结构树检查器 (JSON Tree Inspector)**：
+   - `.json` 文件默认以交互结构树呈现，支持 `Object{N}` 与 `Array[N]` 多层级折叠展开。
+   - 属性名与属性值即时过滤搜索。
+   - 单击快捷复制指定字段路径（如 `scripts.build`）或字段值。
+   - 提供 `⚡ 格式化 (2空格对齐)` 与 `🗜️ 压缩 (单行)` 快捷操作，并支持随时切换至高亮代码模式。
+
+4. **🌐 多语言语法高亮与符号大纲 (Polyglot Highlighting & Symbol TOC)**：
+   - 采用单趟扫描分词器（Single-Pass Tokenizer），杜绝 HTML 嵌套污染。
+   - **全面支持主流语言**：
+     - ☕ **Java**：注解（`@Service`, `@Autowired`, `@Override`）、泛型、集合类、文本块、Package/Class/Method 符号大纲。
+     - ⚙️ **C / C++**：预处理指令（`#include <...>`）、命名空间、模板、标准库类型、智能指针、Namespace/Class/Struct/Function 符号大纲。
+     - 🐍 **Python**：装饰器（`@dataclass`, `@property`）、多行 Docstrings、异步协程（`async def`）、类型标注、Class/Def 符号大纲。
+     - ⚡ **JavaScript / TypeScript**：ES 模块、JSX 标签、接口/枚举、模板字符串、箭头函数、Class/Fn/Type/Export 符号大纲。
+     - 🦀 **Rust** / 🌐 **Go** / ⌨️ **Shell** / 🗄️ **SQL** / ⚙️ **YAML** / 📝 **Markdown** 等。
+   - **大纲点击平滑跳转**：点击大纲侧栏任一项，代码区域自动平滑滚动定位至目标代码行，并在行号及对应行触发高亮闪烁反馈。
+   - **代码排版优化**：默认水平滚动，点击 `↩️ 换行` 可在单行与自动折行（`overflow-wrap: break-word`）间无缝切换，杜绝单词被撕裂打碎。
+
+5. **📖 全功能 GFM Markdown 渲染引擎**：
+   - **三模视图切换**：📖 渲染预览 (Preview) / 📝 源码模式 (Source) / 🌓 分栏对比 (Split)。
    - **GitHub Alerts 提示框**：完整支持 `> [!NOTE]`、`> [!TIP]`、`> [!IMPORTANT]`、`> [!WARNING]`、`> [!CAUTION]` 彩色卡片渲染。
-   - **代码块语法高亮**：支持 JavaScript/TypeScript、Python、JSON、Bash、HTML、CSS 等多种语言关键字高亮，顶部附带语言标识与**一键复制代码**按钮。
    - **LaTeX 数学公式**：支持 `$inline$` 与 `$$block$$` 数学公式排版。
    - **数据表格与任务清单**：斑马纹表格自适应排版、交互式勾选框列表。
-   - **目录大纲导航 (TOC)**：自动提取 H1~H6 标题生成侧栏目录，点击平滑滚动跳转至对应章节。
+   - **目录大纲导航 (TOC)**：自动提取 H1~H6 标题生成侧栏目录，点击平滑滚动跳转。
 
-4. **实用操作工具栏**：
-   - 📋 **一键复制 (Copy)**：一键复制完整 Markdown 内容至系统剪贴板。
-   - 🔄 **实时刷新 (Refresh)**：重新从磁盘加载最新文件内容（Agent 持续写入时可一键更新）。
-   - 🖥️ **本地应用打开 (Open Native)**：若确需在系统外部编辑器（记事本/VSCode）中打开，可一键唤起。
-   - 📁 **资源管理器中定位 (Reveal)**：一键调用系统资源管理器定位并高亮选中该文件。
-   - 🔍 **文档内关键词搜索 (Find)**：快速高亮匹配文本。
-   - ✕ **快捷收起与悬浮入口**：支持 Esc 快捷键关闭；收起后右下角保留胶囊浮窗，一键随时恢复展开。
-
-5. **Node 端服务与安全保障**：
-   - 配合 Node 端 Cordis `PreviewService`，提供 `/api/preview/read`、`/api/preview/reveal` 等 REST 路由，解决本地工作区文件跨目录读取与超大文件防护。
+6. **📑 右侧多标签页 (FileTabs)**：
+   - 支持同时打开多个文档与代码文件，标签栏展示对应语言彩色图标、文件名与独立关闭按钮。
+   - 支持快速切换激活标签、一键全部关闭。
+   - 左侧边框支持鼠标自由拖拽调节宽度（支持 380px 至 90vw 自由调整）。
 
 ---
 
@@ -67,32 +75,9 @@ npx @deepseek-ai/dsh web
 
 ---
 
-## 📁 目录结构 (Directory Structure)
-
-```text
-dsh-plugin-preview/
-├── package.json              # 插件元信息与 npm 脚本配置
-├── cordis.patch.yml          # DSH 组合包 patch 描述文件
-├── tsconfig.json             # TypeScript 编译配置
-├── README.md                 # 插件说明文档
-├── scripts/
-│   └── build.js              # 自动构建、分发与补丁安装脚本
-├── src/
-│   ├── types.ts              # 核心 TypeScript 类型定义
-│   ├── service.ts            # Node 端 PreviewService 服务 (HTTP 路由)
-│   ├── index.ts              # Node 端 Cordis Service 注册与 Schema 导出
-│   └── client.js             # Web 浏览器端 React 预览面板与拦截器
-└── lib/
-    ├── index.js              # Node ESM 导出产物
-    ├── index.d.ts            # 类型声明文件
-    └── client.js             # Web 端 ModuleLoader 加载产物
-```
-
----
-
 ## ⚙️ 配置项说明 (Configuration)
 
-可以在 `cordis.patch.yml` 或配置中自定义以下参数：
+可以在 `cordis.patch.yml` 或配置文件中自定义以下参数：
 
 ```yaml
 - id: ui-preview
@@ -106,12 +91,24 @@ dsh-plugin-preview/
       - .json
       - .yaml
       - .yml
+      - .js
+      - .ts
+      - .java
+      - .cpp
+      - .c
+      - .h
+      - .hpp
+      - .py
+      - .go
+      - .rs
+      - .sh
+      - .sql
     # 最大允许读取的文件大小 (MB)
     maxFileSizeMb: 10
-    # 默认打开视图: 'preview' (预览) | 'source' (源码) | 'split' (分栏)
+    # 默认打开视图: 'preview' (预览) | 'source' (源码) | 'split' (分栏) | 'json-tree' (树) | 'code' (代码)
     defaultViewMode: preview
     # 右侧预览面板默认宽度 (px)
-    defaultPanelWidth: 620
+    defaultPanelWidth: 760
 ```
 
 ---

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.6",
+  "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",