source-code-mgmt 1.13.0 → 1.14.0

package/README.en.md

@@ -1,6 +1,6 @@
 # source-code-mgmt — DSH Source Code Management Plugin
 
-> Version: **v1.13.0**　|　中文版见 [README.md](README.md)
+> Version: **v1.14.0**　|　中文版见 [README.md](README.md)
 
 > A source-code management plugin for the DSH Web GUI: it bundles「environment check → SSH setup → commit/push/upload code」into one「Code Management」panel with GitHub / Gitee dual-platform support.
 
@@ -19,7 +19,7 @@ Entry points (auto-detected, no manual switching):
 
 > Detection is a single in-memory read at activation time (`ctx.get('betterSidebar')`) — zero I/O, zero network, no impact on DSH startup.
 
-The panel has six steps (①②③ are the core three; ④⑤⑥ are the newer extensions, collapsed by default):
+The panel has five steps (①②③ are the core three; ④⑤ are the newer extensions, collapsed by default):
 
 ### ① Environment Check
 - Shows the **OS** (friendly names `Windows` / `macOS` / `Linux`, from the underlying `win32` / `darwin` / `linux` platform ids)
@@ -59,13 +59,7 @@ The panel has six steps (①②③ are the core three; ④⑤⑥ are the newer e
 - **Clone into**: optional target parent directory (default = DSH's default workspace; leave empty to clone to the default location); cloning uses the SSH URL and auto-adds the clone to the custom-directory list so ③ can select it directly
 - Repos already present locally can't be re-cloned; every other repo has a「克隆」(clone) button
 
-### ⑤ Pull Request
-- **Target repo recorded locally**: paste the repo URL you want to PR to (`https://github.com/owner/repo`, `owner/repo`, …) → saved to `~/.dsh/storages/source-code-mgmt-pr-targets.json` (**not** the plugin directory); saved repos appear as removable chips and can be re-selected
-- **AI PR-rule analysis**: fetches the target repo's README / CONTRIBUTING / PR template / package.json scripts and has the **DSH default model** figure out how to PR to that repo (e.g. awesome-dsh-plugin: create `data/plugins/<owner>__<repo>.yml`, regenerate the README, satisfy the `dsh.bundle`/commit-count/topic gates), producing a structured **step rule cached in the plugin directory `rules/<owner>__<repo>.json`** — the next PR to the same repo runs straight from cache, **no repeated AI spend**;「Re-analyze (ignore cache)」forces a fresh pass
-- **AI PR-content generation**: fill in the plugin info (owner/repo, category, en/zh description) → AI builds the title + description + entry-file content from the rule template — **fully editable, never submitted directly**
-- **Run PR**: executes the rule steps `fork → clone fork → add upstream → fetch → create branch → write entry → (regenerate README) → commit → push → create PR` (GitHub via `gh pr create`, Gitee via OpenAPI) with per-step logs and the PR link; working dir defaults to the default workspace
-
-### ⑥ Publish npm package
+### ⑤ Publish npm package
 - Five-step wizard (run in the target directory): **① check registry** `npm config get registry` → **② view auth config** `npm config list` (auto-redacts token/auth/password) → **③ verify identity** `npm whoami` → **④ preview packed files** `npm pack --dry-run` (see exactly what would be published, nothing is packed or uploaded) → **⑤ publish** `npm publish`
 - Publishing requires ticking「I've reviewed the above — confirm publishing to the npm registry」first, preventing accidental publishes
 
@@ -212,7 +206,18 @@ dsh plugin --profile web add link:$(pwd)
 
 ## Version history
 
-### v1.13.0 (current)
+### v1.14.0 (current)
+Per your request the **⑤ "Submit PR" feature has been removed**:
+
+- **Front-end**: `lib/client.js` drops the whole `PrSection` (its render in the panel and the "⑤ Submit PR" mention in the panel intro), along with the now-unused `EN_DICT` PR keys.
+- **Host**: `lib/index.js` removes the entire PR implementation — the `/pr/targets`, `/pr/rule`, `/pr/analyze`, `/pr/generate`, `/pr/execute` routes; `prAnalyzeFlow` / `prGenerateFlow` / `prExecuteFlow`; the PR-targets local store (`source-code-mgmt-pr-targets.json`); the PR-rule cache read/write under `rules/` (`readPrRule`/`writePrRule`, etc.); `parseRepoUrl`; `fillPrTemplate`; the safety checks (`safeEntryPath`/`safeRegenerateCommand`); `PRESET_PR_RULES` and the startup rule-seeding call.
+- `llmComplete()` (the generic LLM helper) is kept — it is independent of PR and reusable.
+- Version bumped 1.13.0 → 1.14.0; `package.json` description now drops "AI-assisted Pull Requests". The clone section (by-URL clone, local-exists detection) and ⑥ npm (empty-by-default dir) keep their v1.13.0 behavior unchanged.
+- Scope: `lib/client.js` (refresh to apply), `lib/index.js` (restart dsh web).
+
+> Note: the old `rules/awesome-dsh-plugin__awesome-dsh-plugin.json` preset is no longer referenced by any code — you may delete it or leave it (it doesn't affect anything).
+
+### v1.13.0 (history)
 Second feedback pass (④⑤⑥ interaction tightening):
 
 - **④ "Already local" detection widened to registered dirs**: previously the clone list only checked under the currently-selected clone dir; if you switched the clone target elsewhere (e.g. the `workspace` dir) where a repo already existed, it still showed "cloneable". Now a new `localRepoExistsAnywhere()` checks the selected dir **plus every workspace / favorite dir registered by step ③** (from `~/.dsh/storages/workspace.json` + `source-code-mgmt-dirs.json`) — a repo present in any registered location is marked "Already local". Since clone success already records the destination into favorite dirs, "this location already has the repo" knowledge persists automatically and the list hits on it next time.

package/README.md

@@ -6,7 +6,7 @@
 
 > **界面语言跟随 DSH 设置实时切换**：面板与 host 端消息自动使用 DSH 的语言（设置 → 通用 → 语言），中文 ↔ 英文即时生效，无需重启。
 
-> DSH Web GUI 源代码管理插件：把「环境检查 → SSH 配置 → 代码上传推送 → 克隆仓库 → 提交 PR → 发布 npm 包」整合进「代码管理」面板，支持 GitHub / Gitee 双平台，一键管理代码仓库。
+> DSH Web GUI 源代码管理插件：把「环境检查 → SSH 配置 → 代码上传推送 → 克隆仓库 → 发布 npm 包」整合进「代码管理」面板，支持 GitHub / Gitee 双平台，一键管理代码仓库。
 
 > 入口位置自适应：**已安装 [dsh-better-sidebar](https://github.com/omdsh-dev/DSH-better-sidebar) 时**，「代码管理」作为它侧边栏的一个新 Tab 页面出现（全新侧边栏 Tab）；**未安装时**，「代码管理」按钮位于 DSH **右上角、常驻可见**——有会话时放在「Session 日志」旁边的右对齐列表里，无会话空态时改为一个固定在**右上角**的浮动按钮，点击后打开一个 **dsh-better-sidebar 外观的右侧集成面板**（推挤主内容区）。两种形态都复用同一套面板 UI。
 
@@ -19,7 +19,7 @@
 
 > 检测只是激活时一次内存读取（`ctx.get('betterSidebar')`），零 I/O、零网络，不影响 DSH 启动速度；两种形态间自动切换。未安装 better-sidebar 时入口常驻右上角（有会话=Session 日志旁，空态=固定右上角浮动按钮），空态/新对话也可见。
 
-面板分六步（①②③ 为核心三步，④⑤⑥ 为新扩展板块，默认折叠按需展开）：
+面板分五步（①②③ 为核心三步，④⑤ 为新扩展板块，默认折叠按需展开）：
 
 ### ① 环境检查
 - 显示**操作系统**（美化名：`Windows` / `macOS` / `Linux`，对应底层 Node 平台标识 `win32` / `darwin` / `linux`）
@@ -65,13 +65,7 @@
 - **克隆到目录**：可选目标父目录（默认 = DSH 默认工作区），不选即克隆到默认位置；克隆走 SSH URL（`git@github.com:…` / `git@gitee.com:…`），成功后自动加入自定义目录列表，③ 里可直接选中
 - 列表里「本地已有」的仓库不可重复克隆，其余每个仓库一个「克隆」按钮
 
-### ⑤ 提交 PR（Pull Request）
-- **目标仓库记录到本地**：填写要提交 PR 的仓库网址（`https://github.com/owner/repo` / `owner/repo` 等）→ 记录到 `~/.dsh/storages/source-code-mgmt-pr-targets.json`（**不写入插件目录**）；已记录仓库以标签展示、点选回填、可删除
-- **AI 分析 PR 规则**：抓取目标仓库的 README / CONTRIBUTING / PR 模板 / package.json scripts，交给 DSH 默认模型**思考该仓库应如何 PR**（如 awesome-dsh-plugin 收录插件：新建 `data/plugins/<owner>__<repo>.yml`、重生成 README、满足 `dsh.bundle`/提交数/topic 等门槛），输出结构化的**步骤规则并缓存到插件目录 `rules/<owner>__<repo>.json`**——下次对同一仓库直接读缓存执行，**不再重复消耗 AI**；「重新分析（忽略缓存）」可强制重新思考
-- **AI 生成 PR 内容**：填插件信息（owner/repo、分类、中英描述）→ AI 按规则模板生成标题 + 描述 + 条目文件内容，**生成后可自由修改，绝不直接提交**
-- **执行 PR**：按规则步骤执行 `fork → 克隆 fork → 加 upstream → 拉取 → 建分支 → 写条目 → （重生成 README）→ 提交 → 推送 → 开 PR`（GitHub 走 `gh pr create`，Gitee 走 OpenAPI），逐步显示执行日志与 PR 链接；工作目录默认 = 默认工作区
-
-### ⑥ 发布 npm 包（npm publish）
+### ⑤ 发布 npm 包（npm publish）
 - 五步向导（在目标目录执行）：**① 确认源** `npm config get registry` → **② 查看认证配置** `npm config list`（自动脱敏 token/auth/password）→ **③ 验证身份** `npm whoami` → **④ 预览打包** `npm pack --dry-run`（先看会发布哪些文件，不真正打包发布）→ **⑤ 发布** `npm publish`
 - 发布前必须勾选「我已核对以上内容，确认发布到 npm registry」才可点「发布」，防止误操作
 
@@ -213,7 +207,18 @@ dsh plugin --profile web add link:$(pwd)
 
 ## 版本历史
 
-### v1.13.0（当前）
+### v1.14.0（当前）
+按你的要求**移除了 ⑤「提交 PR」功能**：
+
+- **前端**：`lib/client.js` 删除整个 `PrSection`（含 ⑤ 区块的渲染与面板导语中的「⑤提交 PR」文案），一并清理了对应的 i18n 键（`EN_DICT`）。
+- **host**：`lib/index.js` 删除整套 PR 实现——`/pr/targets`、`/pr/rule`、`/pr/analyze`、`/pr/generate`、`/pr/execute` 五个路由，`prAnalyzeFlow` / `prGenerateFlow` / `prExecuteFlow`，PR 目标仓库本地存储（`source-code-mgmt-pr-targets.json`）、PR 规则缓存读写（`rules/` 下的 `readPrRule`/`writePrRule` 等）、`parseRepoUrl`、`fillPrTemplate`、安全校验（`safeEntryPath` / `safeRegenerateCommand`）、`PRESET_PR_RULES` 与启动时的规则预置写入。
+- 保留 `llmComplete()` 这一通用 LLM 调用助手（与 PR 无关，属可复用能力，本轮暂未用到可直接忽略）。
+- 版本号 1.13.0 → 1.14.0；`package.json` 描述同步去掉「AI-assisted Pull Requests」。克隆板块的「按地址克隆」「本地已有判定」与 ⑥ npm（默认空目录）等仍保持 v1.13.0 行为不变。
+- 变更范围：`lib/client.js`（刷新即生效）、`lib/index.js`（需重启 dsh web）。
+
+> 说明：`rules/` 目录下旧预置文件 `rules/awesome-dsh-plugin__awesome-dsh-plugin.json` 已不再被任何代码引用，可自行删除或保留（不影响功能）。
+
+### v1.13.0（历史）
 按第二轮反馈继续精化（④⑤⑥ 三处交互收敛）：
 
 - **④「本地已有」判定扩大到已登记的目录**：此前克隆列表只在「当前选中的克隆目录」下判定本地是否已有，用户若把克隆目录切到别处（如工作区 `workspace`），明明已存在的仓库仍标「可克隆」。现在新增 `localRepoExistsAnywhere()`：除了当前选中目录，还会遍历 ③ 代码管理登记过的**所有工作区 / 自定义目录**（`~/.dsh/storages/workspace.json` + `source-code-mgmt-dirs.json`）逐一判定——任一被登记的位置已有同名仓库即标「本地已有」；克隆成功后目标目录本就会记入自定义目录，因此「某位置已有该仓库」的知识会自动沉淀下来，下次列表直接命中。

package/lib/client.js

@@ -207,47 +207,9 @@ Object.assign(EN_DICT, {
   "请先登录 GitHub CLI（gh）": "Log in to GitHub CLI (gh) first",
   "需要先配置 Gitee 私人令牌": "Configure the Gitee personal token first",
   "克隆一个账号下的远程仓库到本地": "Clone a remote repo from your account locally",
-  // ⑤ 提交 PR
-  "⑤ 提交 PR": "⑤ Pull Request",
-  "目标仓库地址": "Target repo URL",
-  "（如 https://github.com/owner/repo 或 owner/repo）": "(e.g. https://github.com/owner/repo or owner/repo)",
-  "记录到本地": "Save locally",
-  "已记录仓库": "Saved repos",
-  "分析 PR 规则": "Analyze PR rules",
-  "重新分析（忽略缓存）": "Re-analyze (ignore cache)",
-  "AI 正在思考该仓库的 PR 规则…": "AI is analyzing this repo's PR rules…",
-  "已使用缓存规则（插件目录 rules/，无需重新分析）": "Using cached rules (plugin rules/ dir, no re-analysis needed)",
-  "AI 已生成规则并缓存到插件目录 rules/": "AI generated rules and cached them in the plugin rules/ dir",
-  "规则步骤：": "Rule steps: ",
-  "上游分支（base）": "Upstream branch (base)",
-  "PR 标题": "PR title",
-  "PR 描述": "PR description",
-  "条目文件内容（entry，可留空）": "Entry file content (entry, optional)",
-  "插件信息（供 AI 生成 PR 描述）": "Plugin info (for AI to generate the PR description)",
-  "插件名 owner/repo": "Plugin name owner/repo",
-  "分类 category": "Category",
-  "描述 en": "Description (en)",
-  "描述 zh": "Description (zh)",
-  "生成 PR 内容（AI）": "Generate PR content (AI)",
-  "已生成，请确认 / 修改后再执行": "Generated — review / edit before running",
-  "执行 PR": "Run PR",
-  "PR 执行中…": "Running PR…",
-  "PR 已创建：": "PR created: ",
-  "PR 流程已完成": "PR flow completed",
-  "PR 执行失败": "PR flow failed",
-  "PR 执行失败：": "PR flow failed: ",
-  "工作目录（fork 克隆位置，默认=默认工作区）": "Working dir (where the fork is cloned; default = default workspace)",
-  "生成失败": "Generation failed",
-  "生成失败：": "Generation failed: ",
-  "分析失败": "Analysis failed",
-  "分析失败：": "Analysis failed: ",
-  "请填写目标仓库地址": "Enter the target repo URL first",
-  "请先填写仓库并分析规则": "Enter the repo and analyze its rules first",
-  "保存失败": "Save failed",
-  "目标仓库地址会记录到本地 ~/.dsh/storages（不写入插件目录）": "Target repo URLs are saved to local ~/.dsh/storages (not the plugin dir)",
   "删除": "Remove",
-  // ⑥ 发布 npm 包
-  "⑥ 发布 npm 包": "⑥ Publish npm package",
+  // ⑤ 发布 npm 包
+  "⑤ 发布 npm 包": "⑤ Publish npm package",
   "目标目录（含 package.json）": "Target dir (contains package.json)",
   "① 确认源（registry）": "① Check registry",
   "② 查看认证配置（config list）": "② Auth config (config list)",
@@ -267,7 +229,7 @@ Object.assign(EN_DICT, {
   "发布失败：": "Publish failed: ",
   "读取 npm 状态失败：": "Failed to read npm status: ",
   "发布 npm 包五步向导：确认源 → 认证配置 → 身份 → 打包预览 → 发布": "Five-step npm publish guide: registry → auth config → identity → pack preview → publish",
-  "按顺序完成：①环境检查 → ②SSH 密钥与连接 → ③代码管理，以及 ④克隆仓库 / ⑤提交 PR / ⑥发布 npm 包。推送会自动忽略 >100MB 的文件（": "In order: ①Environment → ②SSH key & connection → ③Code management, plus ④Clone repos / ⑤Pull Request / ⑥Publish npm. Pushing auto-ignores >100MB files (",
+  "按顺序完成：①环境检查 → ②SSH 密钥与连接 → ③代码管理，以及 ④克隆仓库 / ⑤发布 npm 包。推送会自动忽略 >100MB 的文件（": "In order: ①Environment → ②SSH key & connection → ③Code management, plus ④Clone repos / ⑤Publish npm. Pushing auto-ignores >100MB files (",
   " 限制）并说明原因。": " limit) with a reason.",
   // ④ 目录选择（复用 ③ 的「选择目录」交互）
   "克隆到目录（默认=用户主目录 home）": "Clone into (default = user home directory)",
@@ -276,18 +238,8 @@ Object.assign(EN_DICT, {
   "已记住目录": "Directory remembered",
   "记住目录失败：": "Failed to remember dir: ",
   "目录不存在或不是文件夹：": "Directory does not exist or is not a folder: ",
-  // ⑤ 通用 PR 流程
-  "通用 PR 流程（未分析，可点击「分析 PR 规则」生成专属规则）": "Generic PR flow (not analyzed — click \"Analyze PR rules\" to generate a repo-specific one)",
-  "该仓库暂无本地规则": "No local rule for this repo yet",
-  "已加载本地规则（插件目录 rules/）": "Loaded local rule (plugin rules/ dir)",
-  "请先分析该仓库的 PR 规则再执行": "Analyze this repo's PR rules before running",
-  "已按模板生成（可编辑，未消耗 AI）": "Generated from the template (editable, no AI spent)",
-  "分析完成，规则已缓存到插件目录 rules/（下次直接使用，无需重新分析）": "Analyzed — rule cached to the plugin rules/ dir (used directly next time)",
-  "该仓库暂无本地规则，当前为通用 PR 流程": "No local rule for this repo yet — showing the generic PR flow",
-  "点击「分析 PR 规则」可让 AI 生成该仓库专属规则（并缓存到插件目录 rules/）": "Click \"Analyze PR rules\" to have AI generate a repo-specific rule (cached to the plugin rules/ dir)",
-  "已加载预置规则（插件目录 rules/）": "Preset rule loaded (plugin rules/ dir)",
   "可手动输入/粘贴目录绝对路径，或点击「浏览…」弹出本地文件夹选择器。确认后将添加到常用目录并记住，下次打开无需重新选择。": "Type/paste an absolute path, or click \"Browse…\" to open the native folder picker. Confirming adds it to your favorite dirs so you won't re-pick it next time.",
-  // ⑥ npm 登录与目录
+  // ⑤ npm 登录与目录
   "未登录 npm，发布前需先登录": "Not logged in to npm — log in before publishing",
   "打开终端执行 npm login": "Open a terminal to run npm login",
   "复制登录命令": "Copy login command",
@@ -298,22 +250,7 @@ Object.assign(EN_DICT, {
   "请手动在终端运行：": "Run this manually in a terminal: ",
   "已复制：": "Copied: ",
   "目录不存在：": "Directory does not exist: ",
-  "确保 fork": "Ensure fork",
-  "克隆 fork": "Clone fork",
-  "加上游": "Add upstream",
-  "拉取上游": "Fetch upstream",
-  "新建分支": "Create branch",
-  "写入条目": "Write entry",
   "提交": "Commit",
-  "推送": "Push",
-  "创建 PR": "Create PR",
-  "该仓库已有规则，是否重新分析？": "A rule already exists for this repo — re-analyze?",
-  "分析 PR 规则（可选：手动填写规则或规则文件，留空则由 AI 自动查找）": "Analyze PR rules (optional: type the rules or a rule file; leave empty and AI will find them)",
-  "手动填写该仓库的 PR 规则（可选）": "Manually type this repo's PR rules (optional)",
-  "或提供规则文件（本地路径 / URL，如某仓库 README）": "Or provide a rules file (local path / URL, e.g. a repo README)",
-  "留空则由 AI 自动抓取该仓库文档（README / CONTRIBUTING / PR 模板）分析": "Leave empty and AI will auto-fetch this repo's docs (README / CONTRIBUTING / PR template)",
-  "开始分析": "Start analysis",
-  "已按你提供的规则分析并缓存到插件目录 rules/": "Analyzed with your supplied rules and cached to the plugin rules/ dir",
   "取消": "Cancel",
   // ④ 按地址克隆
   "也可以按仓库地址克隆到任意位置": "You can also clone any repo by URL into any location",
@@ -322,12 +259,7 @@ Object.assign(EN_DICT, {
   "请输入仓库地址": "Enter a repo URL",
   "请选择克隆到目录": "Choose a destination directory first",
   "无法从地址识别仓库名称": "Cannot derive a repo name from this URL",
-  // ⑤ 固定 awesome-dsh-plugin 收录 PR
-  "⑤ 提交 awesome-dsh-plugin 插件收录 PR": "⑤ Submit an awesome-dsh-plugin listing PR",
-  "目标仓库": "Target repo",
-  "已加载该仓库的收录规则（预置）": "Loaded this repo's listing rules (preset)",
-  "正在加载收录规则…": "Loading listing rules…",
-  // ⑥ 目录默认留空，需手动选择
+  // ⑤ 目录默认留空，需手动选择
   "请先选择目标目录": "Choose a target directory first",
   "请先选择目标目录（当前留空，不会自动使用默认目录）": "Choose a target directory first (left empty on purpose — it will NOT auto-use the default dir)",
 });
@@ -1624,7 +1556,7 @@ function useSession() {
 			};
 		}
 
-		/** Shared text input style for the new sections (④⑤⑥). */
+		/** Shared text input style for the new sections (④⑤). */
 		function inputStyle() {
 			return {
 				flex: 1, minWidth: 0, font: "inherit", fontSize: 12,
@@ -1980,135 +1912,9 @@ function useSession() {
 			);
 		}
 
-		// ---------- section 5: 提交 PR ----------
-		// ⑤ 固定目标仓库：awesome-dsh-plugin 插件收录 PR（隐藏地址输入 / 记录 / 规则分析）。
-		const PR_TARGET_URL = "https://github.com/awesome-dsh-plugin/awesome-dsh-plugin";
-		function PrSection() {
-			const [url, setUrl] = useState(PR_TARGET_URL);
-			const [rule, setRule] = useState(null);       // 预置规则
-			const [ruleCached, setRuleCached] = useState(false);
-			const [ruleSource, setRuleSource] = useState(null); // 'preset' | 'cached' | null
-			const [workdir, setWorkdir] = useState("");
-			const [pName, setPName] = useState("");
-			const [pCategory, setPCategory] = useState("");
-			const [pDescEn, setPDescEn] = useState("");
-			const [pDescZh, setPDescZh] = useState("");
-			const [title, setTitle] = useState("");
-			const [body, setBody] = useState("");
-			const [entry, setEntry] = useState("");
-			const [genBusy, setGenBusy] = useState(false);
-			const [execBusy, setExecBusy] = useState(false);
-			const [logs, setLogs] = useState([]);
-			const [prUrl, setPrUrl] = useState(null);
-			const [msg, setMsg] = useState(null);
-			const [err, setErr] = useState(null);
-
-			useEffect(() => { jget("/clone/default-dir").then((r) => { if (r && r.ok && r.dir) setWorkdir(r.dir); }).catch(() => {}); }, []);
-
-			// 加载 awesome-dsh-plugin 预置规则（只读，不触发 AI、不生成）。固定目标地址，仅挂载时查一次。
-			const lookupRule = useCallback(async (u) => {
-				const urlTxt = String(u || "").trim();
-				try {
-					const r = await jget("/pr/rule?url=" + encodeURIComponent(urlTxt));
-					if (r && r.ok) {
-						if (r.hasRule && r.rule) {
-							setRule(r.rule);
-							setRuleCached(true);
-							setRuleSource(r.rule.preset ? "preset" : "cached");
-							setErr(null);
-						} else {
-							setRule(null);
-							setRuleCached(false);
-							setRuleSource(null);
-						}
-					}
-				} catch (e) { /* 静默：保持现状 */ }
-			}, []);
-			useEffect(() => { void lookupRule(PR_TARGET_URL); }, [lookupRule]);
-
-			const generate = useCallback(async () => {
-				const u = String(url || "").trim();
-				if (!u || !rule) { setErr(t("请先填写仓库并分析规则")); return; }
-				setGenBusy(true); setErr(null); setMsg(null);
-				try {
-					const r = await jpost("/pr/generate", {
-						url: u, rule,
-						pluginInfo: { name: pName, category: pCategory, descriptionEn: pDescEn, descriptionZh: pDescZh },
-					});
-					if (r && r.ok) {
-						setTitle(r.title || ""); setBody(r.body || ""); setEntry(r.entry || "");
-						setMsg(r.fromTemplate ? t("已按模板生成（可编辑，未消耗 AI）") : t("已生成，请确认 / 修改后再执行"));
-					} else setErr((r && r.error) || t("生成失败"));
-				} catch (e) { setErr(t("生成失败：") + e); }
-				finally { setGenBusy(false); }
-			}, [url, rule, pName, pCategory, pDescEn, pDescZh]);
-
-			const execute = useCallback(async () => {
-				const u = String(url || "").trim();
-				if (!u || !rule) { setErr(t("请先填写仓库并分析规则")); return; }
-				setExecBusy(true); setErr(null); setMsg(null); setLogs([]); setPrUrl(null);
-				try {
-					const r = await jpost("/pr/execute", {
-						url: u, workdir, rule, entryContent: entry, title, body,
-						base: (rule && rule.baseBranch) || "main",
-					});
-					setLogs((r && r.logs) || []);
-					if (r && r.ok) {
-						if (r.prUrl) { setPrUrl(r.prUrl); setMsg(t("PR 已创建：") + r.prUrl); }
-						else setMsg(t("PR 流程已完成"));
-					} else setErr((r && r.error) || t("PR 执行失败"));
-				} catch (e) { setErr(t("PR 执行失败：") + e); }
-				finally { setExecBusy(false); }
-			}, [url, rule, workdir, entry, title, body]);
-
-			return h(Box, { title: t("⑤ 提交 awesome-dsh-plugin 插件收录 PR"), defaultCollapsed: true },
-				h("div", { style: { fontSize: 11, color: T.secondary, marginBottom: 8, lineHeight: 1.6 } },
-					t("目标仓库") + ": https://github.com/awesome-dsh-plugin/awesome-dsh-plugin　" +
-					(rule ? t("已加载该仓库的收录规则（预置）") : t("正在加载收录规则…"))),
-				h("div", { style: { border: "1px solid " + T.border, borderRadius: 8, padding: 8, marginBottom: 8 } },
-					h("div", { style: { fontSize: 12, fontWeight: 600, color: T.label, marginBottom: 6 } }, t("插件信息（供 AI 生成 PR 描述）")),
-					h(Field, { label: t("插件名 owner/repo") }, h("input", { type: "text", value: pName, placeholder: "Zhucy123/source-code-mgmt", onChange: (e) => setPName(e.target.value), style: inputStyle() })),
-					h(Field, { label: t("分类 category") }, h("input", { type: "text", value: pCategory, placeholder: "git", onChange: (e) => setPCategory(e.target.value), style: inputStyle() })),
-					h(Field, { label: t("描述 en") }, h("input", { type: "text", value: pDescEn, onChange: (e) => setPDescEn(e.target.value), style: inputStyle() })),
-					h(Field, { label: t("描述 zh") }, h("input", { type: "text", value: pDescZh, onChange: (e) => setPDescZh(e.target.value), style: inputStyle() })),
-					h("div", { style: { display: "flex", gap: 8, marginTop: 6 } },
-						h(Btn, { label: genBusy ? t("生成中…") : t("生成 PR 内容（AI）"), onClick: generate, disabled: genBusy || !url || !rule, tone: "primary", noBg: true }),
-					),
-				),
-				h("div", { style: { marginBottom: 6 } },
-					h("div", { style: { color: T.secondary, fontSize: 12, marginBottom: 4 } }, t("PR 标题")),
-					h("input", { type: "text", value: title, onChange: (e) => setTitle(e.target.value), style: inputStyle() }),
-				),
-				h("div", { style: { marginBottom: 6 } },
-					h("div", { style: { color: T.secondary, fontSize: 12, marginBottom: 4 } }, t("PR 描述")),
-					h("textarea", { rows: 3, value: body, onChange: (e) => setBody(e.target.value), style: { ...inputStyle(), minHeight: 60, resize: "vertical" } }),
-				),
-				h("div", { style: { marginBottom: 6 } },
-					h("div", { style: { color: T.secondary, fontSize: 12, marginBottom: 4 } }, t("条目文件内容（entry，可留空）")),
-					h("textarea", { rows: 4, value: entry, onChange: (e) => setEntry(e.target.value), style: { ...inputStyle(), minHeight: 70, resize: "vertical", fontFamily: "var(--ds-font-family-code, ui-monospace, monospace)", fontSize: 11 } }),
-				),
-				h("div", { style: { marginBottom: 6 } },
-					h("div", { style: { color: T.secondary, fontSize: 12, marginBottom: 4 } }, t("工作目录（fork 克隆位置，默认=默认工作区）")),
-					h("input", { type: "text", value: workdir, onChange: (e) => setWorkdir(e.target.value), style: inputStyle() }),
-				),
-				h("div", { style: { display: "flex", gap: 8, marginTop: 6, alignItems: "center", flexWrap: "wrap" } },
-					h(Btn, { label: execBusy ? t("PR 执行中…") : t("执行 PR"), onClick: execute, disabled: execBusy || !url || !rule, tone: "success" }),
-					prUrl ? h("a", { href: prUrl, target: "_blank", rel: "noreferrer", style: { color: T.brand, fontSize: 12 } }, prUrl) : null,
-				),
-				logs.length > 0 ? h("div", { style: { marginTop: 8, maxHeight: 200, overflow: "auto", background: T.layer1, borderRadius: 8, padding: 8 } },
-					logs.map((lg, i) =>
-						h("div", { key: i, style: { fontSize: 11, lineHeight: 1.6 } },
-							h("span", { style: { color: lg.ok ? T.success : T.danger, fontWeight: 600, marginRight: 6 } }, (lg.ok ? "✅" : "❌") + " " + (lg.label || "")),
-							lg.output ? h("span", { style: { color: T.secondary } }, lg.output) : null
-						)
-					)
-				) : null,
-				msg ? h("div", { style: { color: T.success, fontSize: 12, marginTop: 6 } }, "✅ " + msg) : null,
-				err ? h("div", { style: { color: T.danger, fontSize: 12, marginTop: 6 } }, "❌ " + err) : null,
-			);
-		}
+		
 
-		// ---------- section 6: 发布 npm 包 ----------
+		// ---------- section 5: 发布 npm 包 ----------
 		function NpmSection() {
 			const [dir, setDir] = useState("");
 			const [dirs, setDirs] = useState([]);
@@ -2132,7 +1938,7 @@ function useSession() {
 						jget("/workspaces").catch(() => null),
 					]);
 					const list = [];
-					// ⑥ 目标目录默认留空，由用户手动选择（不复选默认目录）。
+					// ⑤ 目标目录默认留空，由用户手动选择（不复选默认目录）。
 					if (def && def.dir) { if (!list.includes(def.dir)) list.push(def.dir); }
 					if (ws) {
 						if (Array.isArray(ws.workspaces)) for (const w of ws.workspaces) if (!list.includes(w)) list.push(w);
@@ -2220,7 +2026,7 @@ function useSession() {
 				{ key: "publish", label: t("⑤ 发布（publish）") },
 			];
 
-			return h(Box, { title: t("⑥ 发布 npm 包"), defaultCollapsed: true },
+			return h(Box, { title: t("⑤ 发布 npm 包"), defaultCollapsed: true },
 				h("div", { style: { fontSize: 11, color: T.secondary, marginBottom: 8 } }, t("发布 npm 包五步向导：确认源 → 认证配置 → 身份 → 打包预览 → 发布")),
 				h("div", { style: { display: "flex", gap: 8, marginBottom: 8, alignItems: "center" } },
 					h("span", { style: { color: T.secondary, fontSize: 12, whiteSpace: "nowrap" } }, t("目标目录（含 package.json）")),
@@ -2321,7 +2127,7 @@ function useSession() {
 					variant === "tab" ? null : h("button", { type: "button", style: closeBtnStyle(T), "aria-label": t("关闭"), onClick: onClose }, "✕")
 				),
 				h("p", { style: { margin: "6px 0 14px", color: T.secondary, fontSize: 12, lineHeight: 1.6 } },
-					t("按顺序完成：①环境检查 → ②SSH 密钥与连接 → ③代码管理，以及 ④克隆仓库 / ⑤提交 PR / ⑥发布 npm 包。推送会自动忽略 >100MB 的文件（") + (provider === "gitee" ? "Gitee" : "GitHub") + t(" 限制）并说明原因。")),
+					t("按顺序完成：①环境检查 → ②SSH 密钥与连接 → ③代码管理，以及 ④克隆仓库 / ⑤发布 npm 包。推送会自动忽略 >100MB 的文件（") + (provider === "gitee" ? "Gitee" : "GitHub") + t(" 限制）并说明原因。")),
 				h(EnvSection, null),
 				h("div", { style: { height: 12 } }),
 				h(SshSection, { provider, setProvider }),
@@ -2330,8 +2136,6 @@ function useSession() {
 				h("div", { style: { height: 12 } }),
 				h(CloneSection, { provider, setProvider }),
 				h("div", { style: { height: 12 } }),
-				h(PrSection, null),
-				h("div", { style: { height: 12 } }),
 				h(NpmSection, null)
 			);
 		}

package/lib/index.js

@@ -30,7 +30,7 @@ import { fileURLToPath } from 'node:url'
 // ---------- i18n: host messages follow the client’s language (?lang= query param, per request) ----------
 const HOST_EN = {"尚未配置 Gitee 私人令牌（请打开 ③ 代码管理输入令牌）":"No Gitee personal token configured (enter one in ③ Code Management)","Gitee API 请求失败（需要 curl）":"Gitee API request failed (curl required)","not a git repository（尚未 git init，可用「新建仓库并推送」初始化为 git 仓库并上传）":"not a git repository (run \"Create repo & push\" to init one and upload)","超过 GitHub 100MB 单文件限制（${}），已被 .gitignore 的 \"${}\" 排除":"Exceeds GitHub's 100MB file limit (${}) — already excluded by .gitignore entry \"${}\"","超过 GitHub 100MB 单文件限制（${}），${} 所在的一级目录「${}」整体忽略（该文件夹为一整体）":"Exceeds GitHub's 100MB file limit (${}) — the whole first-level folder \"${}\" of ${} is ignored (the folder is one unit)","超过 GitHub 100MB 单文件限制（${}），已忽略单个文件「${}」":"Exceeds GitHub's 100MB file limit (${}) — the file \"${}\" was ignored individually","尚未配置远程仓库 origin，请使用「新建仓库」创建远程仓库。":"No origin remote configured — use \"Create repo\" to create a remote repo.","not a git repository（尚未 git init，无法拉取）":"not a git repository (no git init yet — cannot pull)","尚未配置远程仓库 origin，无法拉取。":"No origin remote configured — cannot pull.","拉取存在冲突：本地有未合并改动或与远程冲突，请手动 git pull 处理合并。":"Pull conflicts: you have unmerged local changes or conflicts with the remote — resolve them manually with git pull.","git pull 失败":"git pull failed","not a git repository（尚未 git init）":"not a git repository (run git init first)","拉取并推送失败：合并存在冲突，请手动解决后重试。":"Pull-and-push failed: merge conflicts — resolve them manually and retry.","pull --rebase 失败":"pull --rebase failed","push 失败":"push failed","push --force 失败":"push --force failed","强制拉取存在冲突，请手动处理。":"Force-pull conflicts — handle them manually.","git pull --force 失败":"git pull --force failed","缺少仓库名称":"Repo name required","仓库名称包含非法字符（仅允许字母、数字、点、下划线、横线）":"Repo name contains invalid characters (only letters, digits, dots, underscores, dashes)","git add 失败：${}":"git add failed: ${}","需要先配置 Gitee 私人令牌":"Configure the Gitee personal token first","Gitee 创建仓库失败":"Failed to create the Gitee repo","缺少文件路径":"File path required","无法识别当前分支":"Cannot determine the current branch","尚未配置远程仓库 origin，无法对齐。":"No origin remote configured — cannot align.","git fetch 失败":"git fetch failed","git reset --hard 失败":"git reset --hard failed","git init 失败":"git init failed","git add 失败":"git add failed","git reset 失败":"git reset failed","提交信息不能为空":"Commit message cannot be empty","没有已暂存（staged）的改动可提交":"Nothing staged to commit","git commit 失败":"git commit failed","缺少分支名":"Branch name required","切换分支失败":"Failed to switch branch","git log 失败":"git log failed","缺少 commit hash":"Commit hash required","revert 失败（可能有冲突，请手动处理）":"revert failed (possible conflicts — handle manually)","cherry-pick 失败（可能有冲突，请手动处理）":"cherry-pick failed (possible conflicts — handle manually)","读取提交 diff 失败":"Failed to read the commit diff","未知工具：":"Unknown tool: ","未找到可用的包管理器（":"No usable package manager found (","）。请手动安装。":"). Please install manually.","安装成功":"Installed successfully","安装失败":"Installation failed","$dlg.Description = '选择本地目录';":"$dlg.Description = 'Choose a local folder';","Gitee 修改可见性失败":"Failed to change Gitee visibility","需要先登录 GitHub CLI（gh）":"Log in to the GitHub CLI (gh) first","修改可见性失败：${}":"Failed to change visibility: ${}","gh repo edit 失败":"gh repo edit failed","缺少目录路径":"Folder path required","未选择目录":"No folder selected","目录不存在或不是文件夹：":"Folder does not exist or is not a directory: ","令牌不能为空":"Token cannot be empty","Gitee 令牌无效，请检查（需有 projects 权限）":"Invalid Gitee token — check it (needs projects permission)"};
 const requestLangStore = new AsyncLocalStorage();
-// 新增板块（④克隆 / ⑤PR / ⑥npm）的 host 英文消息，追加进 HOST_EN。
+// 新增板块（④克隆 / ⑤npm）的 host 英文消息，追加进 HOST_EN。
 Object.assign(HOST_EN, {
   "LLM 服务不可用（未加载 llm 服务）": "LLM service unavailable (llm service not loaded)",
   "未找到默认模型配置（agent-default-model）": "No default model config found (agent-default-model)",
@@ -135,7 +135,7 @@ const SSH = resolveBin('ssh', 'DSH_SCM_SSH')
 const SSH_KEYGEN = resolveBin('ssh-keygen', 'DSH_SCM_SSH_KEYGEN')
 /** Resolved path to curl (used to call the Gitee OpenAPI). */
 const CURL = resolveBin('curl', 'DSH_SCM_CURL')
-/** Resolved path to npm (used by the ⑥ publish-npm section). */
+/** Resolved path to npm (used by the ⑤ publish-npm section). */
 const NPM = resolveBin('npm', 'DSH_SCM_NPM')
 
 /**
@@ -1859,7 +1859,7 @@ function installToolFlow(tool) {
 }
 
 // ---------------------------------------------------------------------------
-// ④ 克隆远程仓库 / ⑤ 提交 PR / ⑥ 发布 npm 包 —— host 逻辑
+// ④ 克隆远程仓库 / ⑤ 发布 npm 包 —— host 逻辑
 // ---------------------------------------------------------------------------
 
 // ---------- LLM 辅助：用 DSH 的 llm 服务 + 默认模型（当前对话/默认模型） ----------
@@ -1946,27 +1946,11 @@ function cloneHomeDir() {
   return homedir()
 }
 
-/** 默认克隆位置（⑤⑥ 等板块的工作目录兜底）：DSH 默认工作区。 */
+/** 默认克隆位置（⑤ 等板块的工作目录兜底）：DSH 默认工作区。 */
 function cloneDefaultDir() {
   return resolveDefaultDir(process.cwd())
 }
 
-/**
- * 从仓库 URL / SSH 地址 / owner/repo 解析平台、owner、repo。
- * @param {string} raw - https://github.com/owner/repo | git@github.com:owner/repo.git | owner/repo
- * @returns {{provider:'github'|'gitee', owner:string, repo:string}|{}}
- */
-function parseRepoUrl(raw) {
-  const url = String(raw || '').trim()
-  if (!url) return {}
-  const gh = /github\.com[/:]([^/\s?#]+)\/([^/\s?#]+)/i.exec(url)
-  if (gh) return { provider: 'github', owner: gh[1], repo: gh[2].replace(/\.git$/i, '') }
-  const gt = /gitee\.com[/:]([^/\s?#]+)\/([^/\s?#]+)/i.exec(url)
-  if (gt) return { provider: 'gitee', owner: gt[1], repo: gt[2].replace(/\.git$/i, '') }
-  const bare = /^([\w.-]+)\/([\w.-]+)$/.exec(url)
-  if (bare) return { provider: 'github', owner: bare[1], repo: bare[2].replace(/\.git$/i, '') }
-  return {}
-}
 
 /** 某仓库名在 baseDir 下是否已有同名 git 仓库（含 baseDir 本身就是同名仓库的情形，
  *  如工作区 C:\Users\xxx\workspace 即对应仓库 workspace）。 */
@@ -2087,610 +2071,8 @@ function cloneFlow(url, dest, name) {
   return { ok: true, dir: full, name: repoName }
 }
 
-// ---------- ⑤ 提交 PR（Pull Request） ----------
-
-/** 用户填写的 PR 目标仓库列表（记录到 ~/.dsh/storages，不写入插件目录）。 */
-function prTargetsFile() {
-  return join(homedir(), '.dsh', 'storages', 'source-code-mgmt-pr-targets.json')
-}
-function readPrTargets() {
-  try {
-    const f = prTargetsFile()
-    if (!existsSync(f)) return []
-    const data = JSON.parse(readFileSync(f, 'utf8'))
-    return Array.isArray(data) ? data : []
-  } catch { return [] }
-}
-function savePrTarget(url) {
-  const { provider, owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return readPrTargets()
-  const list = readPrTargets()
-  const clean = list.filter((t) => String(t.url || '').trim().toLowerCase() !== String(url).trim().toLowerCase())
-  clean.unshift({ url: String(url).trim(), provider, owner, repo, addedAt: new Date().toISOString() })
-  try {
-    const f = prTargetsFile()
-    mkdirSync(dirname(f), { recursive: true })
-    writeFileSync(f, JSON.stringify(clean.slice(0, 50), null, 2), 'utf8')
-  } catch { /* ignore */ }
-  return clean
-}
-function removePrTarget(url) {
-  const list = readPrTargets().filter((t) => String(t.url || '').trim().toLowerCase() !== String(url || '').trim().toLowerCase())
-  try {
-    const f = prTargetsFile()
-    mkdirSync(dirname(f), { recursive: true })
-    writeFileSync(f, JSON.stringify(list, null, 2), 'utf8')
-  } catch { /* ignore */ }
-  return list
-}
-
-/** 插件根目录（用于存放 AI 思考出的 PR 规则缓存）。 */
-function pluginRoot() {
-  return dirname(dirname(fileURLToPath(import.meta.url)))
-}
-function prRulesDir() {
-  return join(pluginRoot(), 'rules')
-}
-function prRulePath(owner, repo) {
-  return join(prRulesDir(), owner + '__' + repo + '.json')
-}
-function readPrRule(owner, repo) {
-  try {
-    const p = prRulePath(owner, repo)
-    if (!existsSync(p)) return undefined
-    const data = JSON.parse(readFileSync(p, 'utf8'))
-    return data && typeof data === 'object' ? data : undefined
-  } catch { return undefined }
-}
-function writePrRule(owner, repo, rule) {
-  try {
-    mkdirSync(prRulesDir(), { recursive: true })
-    writeFileSync(prRulePath(owner, repo), JSON.stringify(rule, null, 2), 'utf8')
-    return true
-  } catch { return false }
-}
-
-/** 从 { 到 } 尽量提取 JSON（AI 可能包裹 markdown 代码块）。 */
-function parseJsonLoose(text) {
-  const s = String(text || '').trim()
-  try { return JSON.parse(s) } catch { /* continue */ }
-  const start = s.indexOf('{')
-  const end = s.lastIndexOf('}')
-  if (start === -1 || end <= start) return null
-  try { return JSON.parse(s.slice(start, end + 1)) } catch { return null }
-}
-
-/** 读取 GitHub 仓库内某文件的文本内容（gh api），失败返回 undefined。 */
-function ghFileText(owner, repo, path) {
-  const r = run(GH, ['api', 'repos/' + owner + '/' + repo + '/contents/' + path, '--jq', '.content'], { timeout: 30_000 })
-  if (!r.ok) return undefined
-  try {
-    const b64 = r.stdout.trim()
-    if (!b64) return undefined
-    return Buffer.from(b64, 'base64').toString('utf8')
-  } catch { return undefined }
-}
-
-/** 抓取目标仓库的关键文档（README / CONTRIBUTING / PR 模板 / package.json scripts），供 AI 分析 PR 规则。 */
-async function gatherRepoDocs(provider, owner, repo) {
-  const docs = {}
-  const candidates = [
-    'README.md', 'CONTRIBUTING.md', '.github/CONTRIBUTING.md',
-    '.github/PULL_REQUEST_TEMPLATE.md', '.github/pull_request_template.md', 'package.json',
-  ]
-  for (const c of candidates) {
-    if (provider === 'gitee') {
-      const api = giteeApi('GET', 'repos/' + owner + '/' + repo + '/contents/' + c)
-      if (api.ok && api.data && typeof api.data.content === 'string') {
-        try { docs[c] = Buffer.from(api.data.content, 'base64').toString('utf8') } catch {}
-      }
-    } else {
-      const txt = ghFileText(owner, repo, c)
-      if (txt !== undefined) docs[c] = txt
-    }
-  }
-  return docs
-}
-
-/** AI 思考 PR 规则的 system 提示词：要求输出结构化 JSON（步骤数组）。 */
-const PR_RULE_SYSTEM = [
-  '你是一个开源仓库 PR 流程分析器。用户要往一个 GitHub/Gitee 仓库提交 Pull Request（提交内容通常是「把某个 DSH 插件收录进该仓库的插件列表 / 或按该仓库规则提交一份变更」）。',
-  '请先分析该仓库的 PR 规则（基于 README / CONTRIBUTING / PR 模板 / package.json scripts），然后输出一个 JSON（不要任何多余文字、不要 markdown 代码块，直接输出 JSON 对象）：',
-  '{',
-  '  "baseBranch": "上游默认分支，如 main 或 master",',
-  '  "entryFilePath": "新增条目文件的相对路径（若适用；如 data/plugins/owner__repo.yml），否则 null",',
-  '  "entryTemplate": "条目文件的内容模板（含占位符，如 {NAME} {DESCRIPTION}），若适用；否则 null",',
-  '  "regenerateCommands": ["重生成 README 的命令数组（如 [\\"node\\", \\"scripts/generate-readme.mjs\\"]），没有则为 []"],',
-  '  "prTitle": "PR 标题建议，如 Add owner/repo",',
-  '  "prBodyHint": "PR 描述应包含的要点（中文一句话概括）",',
-  '  "steps": [',
-  '    { "type": "ensure-fork" },',
-  '    { "type": "clone-fork" },',
-  '    { "type": "add-upstream" },',
-  '    { "type": "fetch-upstream" },',
-  '    { "type": "branch", "name": "add-<插件名>" },',
-  '    { "type": "write-entry" },',
-  '    { "type": "regenerate-readme" },',
-  '    { "type": "commit", "message": "Add owner/repo" },',
-  '    { "type": "push" },',
-  '    { "type": "create-pr" }',
-  '  ]',
-  '}',
-  '要求：steps 按真实执行顺序排列，只包含上面列出的 type；不确定的字段给 null 或空数组，不要编造。',
-].join('\n')
 
-/**
- * 用户已提供规则（手动文本或规则文件）时的 system 提示词：忠实整理为结构化 JSON，
- * 不额外抓取仓库文档、不编造——精简提示词以节省 token。
- */
-const PR_RULE_SYSTEM_USER = [
-  '你是一个开源仓库 PR 流程规则整理器。用户已直接提供该仓库的 PR 规则（手写文本或规则文件，如 README / CONTRIBUTING）。',
-  '请把用户提供的规则忠实整理成下面的 JSON（不要任何多余文字、不要 markdown 代码块，直接输出 JSON 对象）：',
-  '{',
-  '  "baseBranch": "上游默认分支，如 main 或 master",',
-  '  "entryFilePath": "新增条目文件的相对路径（若适用；如 data/plugins/owner__repo.yml），否则 null",',
-  '  "entryTemplate": "条目文件的内容模板（含占位符，如 {NAME} {DESCRIPTION}），若适用；否则 null",',
-  '  "regenerateCommands": ["重生成 README 的命令数组（如 [\\"node\\", \\"scripts/generate-readme.mjs\\"]），没有则为 []"],',
-  '  "prTitle": "PR 标题建议，如 Add owner/repo",',
-  '  "prBodyHint": "PR 描述应包含的要点（中文一句话概括）",',
-  '  "steps": [',
-  '    { "type": "ensure-fork" },',
-  '    { "type": "clone-fork" },',
-  '    { "type": "add-upstream" },',
-  '    { "type": "fetch-upstream" },',
-  '    { "type": "branch", "name": "add-<插件名>" },',
-  '    { "type": "write-entry" },',
-  '    { "type": "regenerate-readme" },',
-  '    { "type": "commit", "message": "Add owner/repo" },',
-  '    { "type": "push" },',
-  '    { "type": "create-pr" }',
-  '  ]',
-  '}',
-  '要求：steps 按真实执行顺序排列，只包含上面列出的 type；只依据用户提供的规则整理，不要额外假设、不要编造用户没提到的字段。',
-].join('\n')
-
-/**
- * 解析用户提供的规则来源：ruleText（手写文本）或 ruleFile（本地路径 / http(s) URL）。
- * @param {string} [ruleText] - 用户手动填写的 PR 规则文本。
- * @param {string} [ruleFile] - 规则文件路径或 URL（如某仓库 README）。
- * @returns {Promise<{text?:string, error?:string}>} 读取到的文本或错误。
- */
-async function resolveRuleInput(ruleText, ruleFile) {
-  const text = String(ruleText || '').trim()
-  if (text) return { text }
-  const file = String(ruleFile || '').trim()
-  if (!file) return {}
-  if (/^https?:\/\//i.test(file)) {
-    // 远程 URL：优先 Node 全局 fetch，失败回退 curl。
-    try {
-      if (typeof fetch === 'function') {
-        const ctrl = new AbortController()
-        const timer = setTimeout(() => ctrl.abort(), 20000)
-        try {
-          const resp = await fetch(file, { redirect: 'follow', signal: ctrl.signal })
-          if (resp.ok) {
-            const body = await resp.text()
-            if (body) return { text: body }
-          }
-        } finally { clearTimeout(timer) }
-      }
-    } catch { /* 继续尝试 curl */ }
-    const r = run('curl', ['-sL', '--max-time', '20', file], { timeout: 30000 })
-    if (r.ok && r.stdout) return { text: r.stdout }
-    return { error: tr('规则文件获取失败：') + file }
-  }
-  if (existsSync(file)) {
-    try { return { text: readFileSync(file, 'utf8') } }
-    catch (e) { return { error: tr('规则文件读取失败：') + String((e && e.message) || e) } }
-  }
-  return { error: tr('找不到规则文件：') + file }
-}
-
-/**
- * 分析某仓库的 PR 规则：命中插件目录 rules/ 缓存则直接返回；否则抓取仓库文档（或用户提供的
- * 规则文本/文件）→ LLM 思考 → 保存缓存。
- * @param {*} ctx - cordis context。
- * @param {{url: string, force?: boolean, ruleText?: string, ruleFile?: string}} input -
- *   目标仓库 URL；force=true 忽略缓存重新分析；ruleText/ruleFile 为用户提供的规则来源（可选）。
- */
-async function prAnalyzeFlow(ctx, { url, force, ruleText, ruleFile }) {
-  const { provider, owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return { ok: false, error: tr('无法识别仓库地址：') + String(url || '') }
-  // 用户提供了规则（文本或文件）→ 视为新的分析输入，忽略缓存直接分析。
-  const hasUserInput = !!String(ruleText || '').trim() || !!String(ruleFile || '').trim()
-  if (!force && !hasUserInput) {
-    const cached = readPrRule(owner, repo)
-    if (cached) return { ok: true, cached: true, provider, owner, repo, rule: cached }
-  }
-  let userRule = ''
-  if (hasUserInput) {
-    const r = await resolveRuleInput(ruleText, ruleFile)
-    if (r.error) return { ok: false, error: r.error }
-    userRule = String(r.text || '').trim()
-    if (!userRule) return { ok: false, error: tr('未获取到规则内容（文件为空或无法读取）') }
-  }
-  let system, messages, docSources
-  if (userRule) {
-    system = PR_RULE_SYSTEM_USER
-    messages = [{
-      role: 'user',
-      text: '目标仓库：' + provider + ' ' + owner + '/' + repo + '\n\n用户提供的该仓库 PR 规则（请忠实整理，不要编造）：\n' + userRule.slice(0, 20000),
-    }]
-    docSources = []
-  } else {
-    const docs = await gatherRepoDocs(provider, owner, repo)
-    system = PR_RULE_SYSTEM
-    messages = [{
-      role: 'user',
-      text: '目标仓库：' + provider + ' ' + owner + '/' + repo + '\n\n仓库关键文档（尽力抓取，可能不全）：\n'
-        + (Object.keys(docs).length ? JSON.stringify(docs, null, 2).slice(0, 12000) : '(无可用文档)'),
-    }]
-    docSources = Object.keys(docs)
-  }
-  const res = await llmComplete(ctx, { system, messages, maxTokens: 3000, temperature: 0.3 })
-  if (!res.ok) return res
-  const rule = parseJsonLoose(res.text)
-  if (!rule || typeof rule !== 'object') return { ok: false, error: tr('AI 未输出有效规则') }
-  if (!Array.isArray(rule.steps)) rule.steps = []
-  rule.owner = owner; rule.repo = repo; rule.provider = provider
-  rule.generatedAt = new Date().toISOString()
-  rule.model = res.model
-  rule.docSources = docSources
-  if (userRule) rule.userProvided = true
-  writePrRule(owner, repo, rule)
-  return { ok: true, cached: false, provider, owner, repo, rule, model: res.model }
-}
-
-/**
- * 用 AI 生成 PR 内容（标题 + 描述 + 条目文件内容）。生成后由用户在 UI 里修改，不直接提交。
- * 当规则自带 entryTemplate 且插件信息齐全时，直接按模板本地填充（零 AI 消耗、可编辑）；
- * 否则调用 LLM 生成。
- * @param {*} ctx - cordis context。
- * @param {{url: string, rule?: object, pluginInfo?: object}} input
- */
-async function prGenerateFlow(ctx, { url, rule, pluginInfo }) {
-  const { owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return { ok: false, error: tr('无法识别仓库地址：') + String(url || '') }
-  const info = (pluginInfo && typeof pluginInfo === 'object') ? pluginInfo : {}
-  const vars = { owner, repo, info }
-
-  // 模板直填路径：规则带 entryTemplate 时按 {VAR} 占位符本地生成（零 AI，仍可编辑）。
-  if (rule && typeof rule.entryTemplate === 'string' && rule.entryTemplate !== '') {
-    const entry = fillPrTemplate(rule.entryTemplate, vars)
-    const title = fillPrTemplate(String(rule.prTitle || 'Add {NAME}'), vars) || ('Add ' + owner + '/' + repo)
-    const body = fillPrTemplate(String(rule.prBodyHint || ''), vars)
-    return {
-      ok: true,
-      title,
-      body,
-      entry,
-      fromTemplate: true,
-      provider: rule.provider || undefined,
-      model: rule.model || 'template',
-    }
-  }
-
-  const system = [
-    '你是 PR 内容生成助手。下面给出目标仓库的 PR 规则与用户要提交的插件信息，请生成三样内容并输出 JSON：',
-    '{ "title": "PR 标题", "body": "PR 描述（markdown，说明改动内容、已满足的前置条件）", "entry": "条目文件内容（若规则有 entryFilePath/entryTemplate 则按模板生成；否则 null）" }',
-    '直接输出 JSON，不要 markdown 代码块，不要多余文字。',
-  ].join('\n')
-  const messages = [{
-    role: 'user',
-    text: '目标仓库规则：\n' + JSON.stringify(rule || {}, null, 2) + '\n\n用户要提交的插件信息：\n' + JSON.stringify(info, null, 2),
-  }]
-  const res = await llmComplete(ctx, { system, messages, maxTokens: 3000, temperature: 0.5 })
-  if (!res.ok) return res
-  const parsed = parseJsonLoose(res.text)
-  if (!parsed || typeof parsed !== 'object') return { ok: false, error: tr('AI 输出无法解析') }
-  return {
-    ok: true,
-    title: String(parsed.title || ''),
-    body: String(parsed.body || ''),
-    entry: parsed.entry == null ? null : String(parsed.entry),
-    provider: res.provider,
-    model: res.model,
-  }
-}
-
-/** 当前分支名（git rev-parse --abbrev-ref HEAD），失败回退 'main'。 */
-function currentBranch(dir) {
-  const r = run(GIT, ['-C', dir, 'rev-parse', '--abbrev-ref', 'HEAD'])
-  return r.ok && r.stdout.trim() && r.stdout.trim() !== 'HEAD' ? r.stdout.trim() : 'main'
-}
-
-/**
- * 校验 PR 规则里的条目文件路径：必须是仓库内相对路径，且解析后不得逃出 cloneDir
- * （防路径穿越 —— 规则来自 AI/缓存，可能被恶意仓库文档诱导出 "../.." 路径）。
- * @param {string} cloneDir - fork 克隆目录。
- * @param {string} p - 规则给出的 entryFilePath。
- * @returns {boolean} 安全则 true。
- */
-function safeEntryPath(cloneDir, p) {
-  if (typeof p !== 'string' || p === '') return false
-  // 绝对路径（Windows 盘符 / POSIX 根 / 反斜杠）一律拒绝。
-  if (/^([a-zA-Z]:[\\/]|\/|\\)/.test(p)) return false
-  // 任何 .. 段（含 \..\、/../、..\ 前缀、../ 前缀）一律拒绝。
-  if (/(^|[\\/])\.\.([\\/]|$)/.test(p)) return false
-  const root = join(cloneDir, p)
-  const base = cloneDir.replace(/[\\/]+$/, '')
-  return root === base || root.startsWith(base + '\\') || root.startsWith(base + '/')
-}
-
-/**
- * 校验 PR 规则里的重生成命令：只允许常见构建/脚本命令 + 纯参数，拒绝绝对路径、
- * 环境变量展开、shell 元字符、重定向与明显危险的命令名。命令本身仍是数组传递
- * （execFileSync 不经过 shell），此校验是纵深防御，防止 AI 规则注入恶意命令。
- * @param {string[]} cmds - [bin, ...args]
- * @returns {boolean}
- */
-const SAFE_REGENERATE_BINS = new Set([
-  'node', 'npm', 'npx', 'pnpm', 'yarn', 'bun',
-  'python', 'python3', 'py',
-  'make', 'cmake',
-  'sh', 'bash', 'zsh',
-  'ruby', 'perl', 'php',
-  'dotnet', 'go', 'cargo', 'rustc',
-  'git', 'awk', 'sed', 'grep', 'cat',
-])
-// 参数不允许 shell 元字符 / 重定向 / 命令替换。命令名已由白名单约束（不经 shell，
-// 数组传递），此处只拦会被 shell 语义扩展、可能被后续误用的字符。
-const SHELL_META_PATTERN = /[|&;<>`$]/
-function safeRegenerateCommand(cmds) {
-  // 兼容两种形态：单条 [bin, ...args] 或多条 [[bin,...],[bin,...]]（顺序执行）。
-  const list = (Array.isArray(cmds) && cmds.length > 0 && Array.isArray(cmds[0])) ? cmds : [cmds]
-  for (const c of list) {
-    if (!Array.isArray(c) || c.length === 0) return false
-    const bin = String(c[0] || '').trim()
-    if (bin === '') return false
-    // 命令名必须是裸名称（不含路径分隔符），且在白名单内。
-    if (/[\\/]/.test(bin)) return false
-    if (!SAFE_REGENERATE_BINS.has(bin)) return false
-    // 参数不允许 shell 元字符 / 重定向。
-    for (let i = 1; i < c.length; i++) {
-      const a = String(c[i] ?? '')
-      if (SHELL_META_PATTERN.test(a)) return false
-    }
-  }
-  return true
-}
-
-/**
- * 用 {VAR} 占位符填充规则模板（OWNER/REPO/NAME/CATEGORY/DESC_EN/DESC_ZH）。
- * @param {string} tpl
- * @param {{owner:string,repo:string,info:object}} vars
- */
-function fillPrTemplate(tpl, vars) {
-  const map = {
-    OWNER: vars.owner,
-    REPO: vars.repo,
-    NAME: String(vars.info && vars.info.name ? vars.info.name : vars.owner + '/' + vars.repo),
-    CATEGORY: String(vars.info && vars.info.category ? vars.info.category : ''),
-    DESC_EN: String(vars.info && vars.info.descriptionEn ? vars.info.descriptionEn : ''),
-    DESC_ZH: String(vars.info && vars.info.descriptionZh ? vars.info.descriptionZh : ''),
-  }
-  return String(tpl ?? '').replace(/\{(OWNER|REPO|NAME|CATEGORY|DESC_EN|DESC_ZH)\}/g, (_, k) => map[k] ?? '')
-}
-
-/**
- * 预置规则：awesome-dsh-plugin 插件收录 PR（依据 提示词.md §2 流程）。
- * 写入插件目录 rules/awesome-dsh-plugin__awesome-dsh-plugin.json；已存在则不覆盖
- * （用户/AI 更新过的规则优先）。
- */
-const PRESET_PR_RULES = [{
-  owner: 'awesome-dsh-plugin',
-  repo: 'awesome-dsh-plugin',
-  rule: {
-    provider: 'github',
-    owner: 'awesome-dsh-plugin',
-    repo: 'awesome-dsh-plugin',
-    baseBranch: 'main',
-    entryFilePath: 'data/plugins/{OWNER}__{REPO}.yml',
-    entryTemplate: [
-      'url: https://github.com/{OWNER}/{REPO}',
-      'name: {NAME}',
-      'category: {CATEGORY}',
-      'description:',
-      "  en: '{DESC_EN}'",
-      "  zh: '{DESC_ZH}'",
-      '',
-    ].join('\n'),
-    regenerateCommands: [['npm', 'ci'], ['node', 'scripts/generate-readme.mjs']],
-    prTitle: 'Add {NAME}',
-    prBodyHint: '新增条目文件 data/plugins/{OWNER}__{REPO}.yml；已运行重生成命令更新 README；仓库已满足 dsh.bundle 声明、满 1 天、提交数 ≥10、dsh-plugin topic；描述已对照源码核实。',
-    steps: [
-      { type: 'ensure-fork' },
-      { type: 'clone-fork' },
-      { type: 'add-upstream' },
-      { type: 'fetch-upstream' },
-      { type: 'branch', name: 'add-{REPO}' },
-      { type: 'write-entry' },
-      { type: 'regenerate-readme' },
-      { type: 'commit', message: 'Add {NAME}' },
-      { type: 'push' },
-      { type: 'create-pr' },
-    ],
-    preset: true,
-    generatedAt: '2026-09 (preset)',
-    model: 'preset',
-  },
-}]
-
-/** 启动时把预置规则写入插件目录 rules/（仅当对应文件不存在）。 */
-function seedPresetPrRules() {
-  for (const p of PRESET_PR_RULES) {
-    if (readPrRule(p.owner, p.repo)) continue
-    writePrRule(p.owner, p.repo, p.rule)
-  }
-}
-
-/**
- * 按规则执行 PR：fork → 克隆 fork → 加 upstream → 拉取 → 建分支 → 写条目 → 重生成 README →
- * 提交 → 推送 → 开 PR（GitHub 走 gh，Gitee 走 OpenAPI）。
- * @param {*} ctx - cordis context。
- * @param {{url: string, workdir?: string, rule?: object, entryContent?: string, title?: string, body?: string, base?: string}} input
- */
-async function prExecuteFlow(ctx, { url, workdir, rule, entryContent, title, body, base }) {
-  const { provider, owner, repo } = parseRepoUrl(url)
-  if (!owner || !repo) return { ok: false, error: tr('无法识别仓库地址：') + String(url || '') }
-  const steps = rule && Array.isArray(rule.steps) ? rule.steps : []
-  if (steps.length === 0) return { ok: false, error: tr('没有可用的 PR 步骤（请先让 AI 分析规则）') }
-  const work = String(workdir || '').trim() || cloneDefaultDir()
-  const cloneDir = join(work, repo)
-  const upstreamUrl = provider === 'gitee'
-    ? 'https://gitee.com/' + owner + '/' + repo + '.git'
-    : 'https://github.com/' + owner + '/' + repo + '.git'
-  const baseBranch = base || (rule && rule.baseBranch) || 'main'
-  const logs = []
-  const stepRun = (label, cmd, args, opts = {}) => {
-    const r = run(cmd, args, { ...opts, timeout: opts.timeout ?? 300_000, cwd: opts.cwd || cloneDir, env: { ...process.env, GIT_SSH: WORKING_SSH, ...(opts.env || {}) } })
-    logs.push({ label, ok: r.ok, output: ((r.stdout || '') + (r.stderr || '')).trim() })
-    return r
-  }
-  for (const s of steps) {
-    const type = s && typeof s === 'object' ? String(s.type || '') : String(s || '')
-    switch (type) {
-      case 'ensure-fork': {
-        if (provider === 'gitee') {
-          const o = giteeOwner()
-          if (!o) return { ok: false, logs, error: tr('需要先配置 Gitee 私人令牌') }
-          const api = giteeApi('POST', 'repos/' + owner + '/' + repo + '/forks')
-          logs.push({ label: tr('确保 fork'), ok: api.ok || giteeApiFailed(api.data) === false, output: (api.error || tr('已 fork 或 fork 已存在')) })
-        } else {
-          const fr = run(GH, ['repo', 'fork', owner + '/' + repo, '--remote=false'], { timeout: 120_000, env: { GIT_SSH: WORKING_SSH } })
-          const blob = ((fr.stdout || '') + (fr.stderr || '')).trim()
-          // gh repo fork 在 fork 已存在时以非零退出并提示 "already exists"，视为成功；
-          // 其他失败（网络/权限）才记为失败。
-          const already = /already exists/i.test(blob)
-          logs.push({ label: tr('确保 fork'), ok: fr.ok || already, output: blob || tr('已 fork 或 fork 已存在') })
-        }
-        break
-      }
-      case 'clone-fork': {
-        if (existsSync(cloneDir) && existsSync(join(cloneDir, '.git'))) {
-          logs.push({ label: tr('克隆 fork'), ok: true, output: tr('已存在本地副本：') + cloneDir })
-        } else {
-          const me = provider === 'gitee' ? (giteeOwner() || owner) : (ghOwner() || owner)
-          const forkUrl = provider === 'gitee'
-            ? ('git@gitee.com:' + me + '/' + repo + '.git')
-            : ('git@github.com:' + me + '/' + repo + '.git')
-          const r = run(GIT, ['clone', forkUrl, cloneDir], { timeout: 600_000, env: { GIT_SSH: WORKING_SSH } })
-          logs.push({ label: tr('克隆 fork'), ok: r.ok, output: ((r.stdout || '') + (r.stderr || '')).trim() || tr('已克隆到 ') + cloneDir })
-          if (!r.ok) return { ok: false, logs, error: tr('克隆 fork 失败') }
-        }
-        break
-      }
-      case 'add-upstream': {
-        let r = stepRun(tr('添加上游'), GIT, ['remote', 'add', 'upstream', upstreamUrl])
-        if (!r.ok) r = stepRun(tr('添加上游'), GIT, ['remote', 'set-url', 'upstream', upstreamUrl])
-        logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || upstreamUrl
-        break
-      }
-      case 'fetch-upstream': {
-        const r = stepRun(tr('拉取上游'), GIT, ['fetch', 'upstream'], { timeout: 120_000 })
-        if (!r.ok) logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('拉取失败')
-        break
-      }
-      case 'branch': {
-        const raw = (s && s.name) || ('add-' + repo)
-        const b = fillPrTemplate(String(raw), { owner, repo, info: {} })
-        const r = stepRun(tr('新建分支'), GIT, ['checkout', '-B', b, 'upstream/' + baseBranch])
-        if (!r.ok) {
-          logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('创建分支失败')
-          // 分支创建失败必须中止：后续 write-entry/commit/push 会在错误的当前分支上
-          // 继续（例如推送到 fork 默认分支），可能造成非预期提交。
-          return { ok: false, logs, error: tr('创建分支失败（上游分支可能不存在，请检查规则 baseBranch）') }
-        }
-        break
-      }
-      case 'write-entry': {
-        const p = fillPrTemplate(String((s && s.path) || (rule && rule.entryFilePath) || '').trim(), { owner, repo, info: {} })
-        if (!p) { logs.push({ label: tr('写入条目'), ok: false, output: tr('缺少条目文件路径') }); break }
-        // 防路径穿越：条目路径必须安全落在 cloneDir 内（规则来自 AI/缓存，可能被诱导）。
-        if (!safeEntryPath(cloneDir, p)) {
-          logs.push({ label: tr('写入条目'), ok: false, output: tr('条目文件路径不安全（已拦截）') + ': ' + p })
-          return { ok: false, logs, error: tr('条目文件路径不安全（已拦截）') }
-        }
-        try {
-          mkdirSync(dirname(join(cloneDir, p)), { recursive: true })
-          writeFileSync(join(cloneDir, p), entryContent || '', 'utf8')
-          logs.push({ label: tr('写入条目'), ok: true, output: p })
-        } catch (e) { logs.push({ label: tr('写入条目'), ok: false, output: String(e) }) }
-        break
-      }
-      case 'regenerate-readme': {
-        const raw = (Array.isArray(s && s.commands) ? s.commands : (rule && rule.regenerateCommands)) || []
-        // 兼容两种形态：单条 [bin, ...args] 或多条 [[bin,...],[bin,...]]（顺序执行）。
-        const cmds = (Array.isArray(raw) && raw.length > 0 && Array.isArray(raw[0])) ? raw : [raw]
-        if (cmds.length > 0) {
-          // 防恶意规则：只允许白名单构建命令 + 安全参数（AI 规则可能注入任意命令）。
-          if (!safeRegenerateCommand(cmds)) {
-            logs.push({ label: tr('重生成 README'), ok: false, output: tr('重生成命令不安全（已拦截）') + ': ' + String(cmds[0] && cmds[0][0] || '') })
-            return { ok: false, logs, error: tr('重生成命令不安全（已拦截）') }
-          }
-          let failed = false
-          for (const c of cmds) {
-            const r = stepRun(tr('重生成 README'), c[0], c.slice(1), { timeout: 180_000 })
-            if (!r.ok) { logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('执行失败'); failed = true; break }
-          }
-          if (failed) return { ok: false, logs, error: tr('执行失败') }
-        } else {
-          logs.push({ label: tr('重生成 README'), ok: true, output: tr('无命令，跳过') })
-        }
-        break
-      }
-      case 'commit': {
-        run(GIT, ['-C', cloneDir, 'add', '-A'])
-        const ident = run(GIT, ['-C', cloneDir, 'config', 'user.email'])
-        if (!ident.ok) {
-          run(GIT, ['-C', cloneDir, 'config', 'user.name', 'DSH User'])
-          run(GIT, ['-C', cloneDir, 'config', 'user.email', 'dsh@localhost'])
-        }
-        const msg = fillPrTemplate(String((s && s.message) || '').trim(), { owner, repo, info: {} }) || ('Add ' + owner + '/' + repo)
-        const r = run(GIT, ['-C', cloneDir, 'commit', '-m', msg], { timeout: 60_000 })
-        logs.push({ label: tr('提交'), ok: r.ok || /nothing to commit|no changes added/i.test(((r.stdout || '') + (r.stderr || ''))), output: ((r.stdout || '') + (r.stderr || '')).trim() || tr('已提交') })
-        break
-      }
-      case 'push': {
-        const r = stepRun(tr('推送'), GIT, ['push', '-u', 'origin', currentBranch(cloneDir)], { timeout: 180_000 })
-        if (!r.ok) {
-          logs[logs.length - 1].output = ((r.stdout || '') + (r.stderr || '')).trim() || tr('推送失败')
-          return { ok: false, logs, error: tr('推送失败') }
-        }
-        break
-      }
-      case 'create-pr': {
-        const titleTxt = String(title || '').trim()
-          || fillPrTemplate(String((s && s.title) || (rule && rule.prTitle) || ''), { owner, repo, info: {} })
-          || ('Add ' + owner + '/' + repo)
-        const bodyTxt = String(body || '').trim()
-        const branchName = currentBranch(cloneDir)
-        if (provider === 'gitee') {
-          const tok = readGiteeToken()
-          const o = giteeOwner()
-          if (!o || !tok) return { ok: false, logs, error: tr('需要先配置 Gitee 私人令牌') }
-          const api = giteeApi('POST', 'repos/' + owner + '/' + repo + '/pulls', { title: titleTxt, head: o + ':' + branchName, base: baseBranch, body: bodyTxt || undefined }, tok)
-          const urlM = api.ok && api.data && typeof api.data.html_url === 'string' ? api.data.html_url : undefined
-          logs.push({ label: tr('创建 PR'), ok: api.ok, output: urlM || (api.error || (api.data && api.data.message) || tr('创建 PR 失败')) })
-          return { ok: api.ok, logs, prUrl: urlM, error: api.ok ? undefined : (api.error || (api.data && api.data.message) || tr('创建 PR 失败')) }
-        }
-        const me = ghOwner() || owner
-        const args = ['pr', 'create', '--repo', owner + '/' + repo, '--head', me + ':' + branchName, '--base', baseBranch, '--title', titleTxt]
-        if (bodyTxt) args.push('--body', bodyTxt)
-        const r = run(GH, args, { timeout: 180_000, cwd: cloneDir, env: { GIT_SSH: WORKING_SSH } })
-        const blob = ((r.stdout || '') + (r.stderr || '')).trim()
-        const urlM = /https:\/\/github\.com\/[^\s"]+/.exec(blob)
-        logs.push({ label: tr('创建 PR'), ok: r.ok, output: blob || tr('已创建 PR') })
-        return { ok: r.ok, logs, prUrl: urlM ? urlM[0] : undefined, error: r.ok ? undefined : (blob || tr('创建 PR 失败')) }
-      }
-      default:
-        logs.push({ label: type || tr('未知步骤'), ok: false, output: tr('未知步骤类型') })
-    }
-  }
-  return { ok: true, logs }
-}
-
-// ---------- ⑥ 发布 npm 包（npm publish） ----------
+// ---------- ⑤ 发布 npm 包（npm publish） ----------
 
 /** npm 状态：是否安装、registry、whoami、目标目录是否存在 package.json。 */
 function npmStatus(dir) {
@@ -3108,8 +2490,6 @@ function baseName(p) {
 }
 
 export function apply(ctx) {
-  // 启动时把预置 PR 规则（awesome-dsh-plugin 等）写入插件目录 rules/（不存在才写）。
-  seedPresetPrRules()
   const fallbackDir = resolveDefaultDir(process.cwd())
   // 每个请求按 ?lang= 参数跑在独立语言上下文里（AsyncLocalStorage），
   // 所有 flow 函数内的 tr() 都能读到当前请求的语言，并发请求互不干扰。
@@ -3380,7 +2760,7 @@ export function apply(ctx) {
     },
 
     // ---- ④ 克隆远程仓库 ----
-    // 默认工作区（⑤⑥ 等板块兜底）。
+    // 默认工作区（⑤ 等板块兜底）。
     '/clone/default-dir': (req, res) => handle(req, res, async () => {
       const dir = cloneDefaultDir()
       return { ok: true, dir, name: baseName(dir) }
@@ -3407,64 +2787,7 @@ export function apply(ctx) {
       })
     },
 
-    // ---- ⑤ 提交 PR ----
-    '/pr/targets': async (req, res) => {
-      if (req.method === 'GET') {
-        await handle(req, res, async () => ({ ok: true, targets: readPrTargets() }))
-      } else if (req.method === 'POST') {
-        await handle(req, res, async (req) => {
-          const body = JSON.parse((await readBody(req)) || '{}')
-          const url = String(body.url || '').trim()
-          if (!url) return { ok: false, error: tr('缺少仓库地址') }
-          if (body.remove) return { ok: true, targets: removePrTarget(url) }
-          return { ok: true, targets: savePrTarget(url) }
-        })
-      } else {
-        return methodNotAllowed(res, req.method)
-      }
-    },
-    // 只读查询某仓库是否有缓存规则（命中插件目录 rules/，不触发 AI，不生成）。
-    '/pr/rule': async (req, res) => {
-      if (req.method !== 'GET') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const q = new URL(req.url ?? '', 'http://localhost')
-        const url = q.searchParams.get('url') || ''
-        const { provider, owner, repo } = parseRepoUrl(url)
-        if (!owner || !repo) return { ok: true, hasRule: false, url: String(url) }
-        const cached = readPrRule(owner, repo)
-        return {
-          ok: true, hasRule: !!cached, url: String(url),
-          provider, owner, repo,
-          rule: cached || null,
-        }
-      })
-    },
-    '/pr/analyze': async (req, res) => {
-      if (req.method !== 'POST') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const body = JSON.parse((await readBody(req)) || '{}')
-        return prAnalyzeFlow(ctx, { url: body.url, force: !!body.force, ruleText: body.ruleText, ruleFile: body.ruleFile })
-      })
-    },
-    '/pr/generate': async (req, res) => {
-      if (req.method !== 'POST') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const body = JSON.parse((await readBody(req)) || '{}')
-        return prGenerateFlow(ctx, { url: body.url, rule: body.rule, pluginInfo: body.pluginInfo })
-      })
-    },
-    '/pr/execute': async (req, res) => {
-      if (req.method !== 'POST') return methodNotAllowed(res, req.method)
-      await handle(req, res, async (req) => {
-        const body = JSON.parse((await readBody(req)) || '{}')
-        return prExecuteFlow(ctx, {
-          url: body.url, workdir: body.workdir, rule: body.rule,
-          entryContent: body.entryContent, title: body.title, body: body.body, base: body.base,
-        })
-      })
-    },
-
-    // ---- ⑥ 发布 npm 包 ----
+    // ---- ⑤ 发布 npm 包 ----
     '/npm/status': async (req, res) => {
       if (req.method !== 'GET') return methodNotAllowed(res, req.method)
       await handle(req, res, async (req) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "source-code-mgmt",
-  "version": "1.13.0",
-  "description": "DSH plugin: source code management. Registers「代码管理」as a dsh-better-sidebar sidebar Tab when installed, otherwise a button in the DSH session header's right-aligned utilities (beside \"Session log\") opening a right-side integrated panel that pushes the main content — env checks (git/gh), SSH ed25519 key setup, GitHub/Gitee dual-platform (SSH config 443 + Gitee OpenAPI), connectivity test, push / new repo, auto-ignore files over 100MB with per-file skipped reasons, plus clone remote repos from your account, AI-assisted Pull Requests with per-repo rule caching, and a five-step npm publish wizard. Cross-platform (Windows / Linux / macOS).",
+  "version": "1.14.0",
+  "description": "DSH plugin: source code management. Registers「代码管理」as a dsh-better-sidebar sidebar Tab when installed, otherwise a button in the DSH session header's right-aligned utilities (beside \"Session log\") opening a right-side integrated panel that pushes the main content — env checks (git/gh), SSH ed25519 key setup, GitHub/Gitee dual-platform (SSH config 443 + Gitee OpenAPI), connectivity test, push / new repo, auto-ignore files over 100MB with per-file skipped reasons, a clone section (remote repos from your account with local-exists detection, plus clone any repo by URL into any location), and a five-step npm publish wizard. Cross-platform (Windows / Linux / macOS).",
   "type": "module",
   "main": "lib/index.js",
   "exports": {