@movemama/opencode-legacy 0.1.0 → 1.0.0

package/README.md

@@ -2,6 +2,8 @@
 
 OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt` 编辑和 legacy 规则路由场景。
 
+当前主链路已经改为纯 JS 编码实现，不再依赖系统外部 `iconv.exe`。
+
 ## 安装
 
 在 OpenCode 配置中加入：
@@ -17,6 +19,8 @@ OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt`
 
 首次未安装的用户会在 OpenCode 启动时自动安装当前 `latest` 版本。后续更新可由用户自行处理。
 
+如果刚安装后没有生效，重新启动一次 OpenCode 即可让 npm 插件完成加载。
+
 ## 当前提供的工具
 
 - `read`
@@ -26,6 +30,7 @@ OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt`
 - `legacy_read`
 - `legacy_write`
 - `legacy_edit`
+- `legacy_status`
 
 其中同名工具 `read`、`write`、`edit` 会覆盖 OpenCode 内置工具，实现 legacy 路由。
 
@@ -39,6 +44,85 @@ OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt`
 2. `<worktree>/legacy-rules.json`
 3. 包内 `legacy-rules.json`
 
+规则字段现在除编码外，还支持：
+
+- `profile`
+- `editStrategy`
+- `fallbackMode`
+- `scriptMarkers`
+
+这让插件可以按场景决定更合适的编辑策略，而不只是按编码读写。
+
+## 自动策略层
+
+当前 `edit` 已经接入自动策略层。
+
+- 普通文本默认走 `exact-first`
+- `classic-tag` 文本可根据 `profile` 和 `scriptMarkers` 判断为更偏 block / line-normalized 的策略
+- `rich-ui-dsl` 文本会优先识别 `<Text|...>` / `<Button|...>` 组件，并在 exact 失败后尝试 widget 字段级更新
+- 失败时会返回当前策略、格式族和 fallback 提示，便于继续排障
+
+## 支持的格式族
+
+- `classic-tag`
+  - 例如 `[@main]`、`<领取/@领取>`、`<关闭/@exit>`
+  - 当前已支持：菜单行宽松匹配、标签块替换、跳转目标校验
+- `rich-ui-dsl`
+  - 例如 `<Text|x=...|text=...>`、`<Button|...|link=@...>`
+  - 当前已支持：多行 widget 定位、字段级更新、children 字段保留
+
+当前这两类是第一批重点支持对象。
+
+- `general-code`
+  - 例如 C++ / C# / 强语法代码文本
+  - 当前仅做安全识别与保守回退，不做激进结构改写
+
+## 诊断工具
+
+可以使用 `legacy_status` 查看：
+
+- 插件版本
+- 规则来源
+- 命中规则
+- 格式族
+- profile
+- 建议策略
+- fallback 模式
+- 是否被判定为脚本型文件
+
+## 如何确认已加载成功
+
+最简单的方法是读取一个命中规则的 `.txt` 文件。
+
+如果插件已接管成功，返回内容中会出现：
+
+```text
+--- Legacy 读取回执 ---
+```
+
+这说明 `read` 工具已经由插件覆盖并进入 legacy 规则链路。
+
+也可以直接调用 `legacy_status` 检查当前文件会命中哪条规则、建议使用哪种策略。
+
+如果检测为 `general-code`，当前插件会优先保持保守，不会像 rich-ui / classic-tag 那样做特化结构修改；这部分为未来语法感知层预留空间。
+
+如果检测为 `classic-tag`，当前插件已能在 exact 失败后继续尝试：
+
+- 菜单行 token 级匹配
+- 标签块局部替换
+- 跳转标签存在性检查
+
+如果检测为 `rich-ui-dsl`，当前插件已能在 exact 失败后继续尝试：
+
+- widget 字段级更新
+- 多行 widget 定位
+- 保留 `children={...}` 容器字段
+
+## 兼容说明
+
+- `txt-gb2312-tool.mjs` 目前仅保留为兼容遗留文件，不再是主链路依赖
+- 当前主运行时入口以 `.js/.mjs` 文件为准
+
 ## 发布
 
 ```bash

package/index.js

@@ -2,6 +2,7 @@ import readTool from './tools/read.js'
 import writeTool from './tools/write.js'
 import editTool from './tools/edit.js'
 import scriptEditTool from './tools/script-edit.js'
+import legacyStatusTool from './tools/legacy-status.js'
 import { edit as legacyEditTool, read as legacyReadTool, write as legacyWriteTool } from './tools/legacy.js'
 
 export const OpenCodeLegacyPlugin = async () => ({
@@ -13,6 +14,7 @@ export const OpenCodeLegacyPlugin = async () => ({
     legacy_read: legacyReadTool,
     legacy_write: legacyWriteTool,
     legacy_edit: legacyEditTool,
+    legacy_status: legacyStatusTool,
   },
 })
 

package/legacy-rules.json

@@ -6,14 +6,33 @@
       "encoding": "gb2312",
       "strict": true,
       "tool": "txt-gb2312",
-      "priority": 10
+      "priority": 10,
+      "profile": "txt-gb2312-safe",
+      "editStrategy": "exact-first",
+      "fallbackMode": "legacy-safe-replace",
+      "scriptMarkers": ["#ACT", "@main", "@全体补偿页面"]
+    },
+    {
+      "glob": "**/*.txt",
+      "encoding": "gb2312",
+      "strict": true,
+      "tool": "txt-gb2312",
+      "priority": 20,
+      "profile": "rich-ui-dsl",
+      "editStrategy": "widget-field",
+      "fallbackMode": "widget-field-update",
+      "scriptMarkers": ["<Text|", "<Button|", "<Img|", "<Layout|"]
     },
     {
       "glob": "**/*.{ini,cfg,dat}",
       "encoding": "gbk",
       "strict": false,
       "tool": "legacy-text",
-      "priority": 1
+      "priority": 1,
+      "profile": "config-gbk",
+      "editStrategy": "exact-first",
+      "fallbackMode": "legacy-safe-replace",
+      "scriptMarkers": []
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@movemama/opencode-legacy",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "OpenCode legacy text processing plugin for GB2312 and script-safe editing workflows.",
   "type": "module",
   "main": "./index.js",
@@ -20,7 +20,8 @@
     "plugin",
     "legacy",
     "gb2312",
-    "iconv"
+    "gbk",
+    "script-edit"
   ],
   "license": "MIT",
   "publishConfig": {

package/tools/edit.js

@@ -1,27 +1,13 @@
 import { tool } from '@opencode-ai/plugin'
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import readTool from './read.js'
 import writeTool from './write.js'
 import { applyLegacyEdit } from './legacy-edit-core.mjs'
-import { createDefaultLegacyRules, matchLegacyRule } from './legacy-router.mjs'
-import { getBundledLegacyRulesPath } from './opencode-paths.mjs'
-
-function loadLegacyRules(worktree) {
-  const candidates = [
-    path.join(worktree, '.opencode', 'legacy-rules.json'),
-    path.join(worktree, 'legacy-rules.json'),
-    getBundledLegacyRulesPath(),
-  ]
-
-  for (const filePath of candidates) {
-    if (existsSync(filePath)) {
-      return JSON.parse(readFileSync(filePath, 'utf8')).rules ?? createDefaultLegacyRules()
-    }
-  }
-
-  return createDefaultLegacyRules()
-}
+import { matchLegacyRule } from './legacy-router.mjs'
+import { loadLegacyRules } from './legacy-rules-loader.js'
+import { chooseEditStrategy } from './legacy-strategy.js'
+import { applyFallbackEditChain } from './legacy-widget-edit.js'
 
 function resolvePath(filePath, worktree) {
   return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)
@@ -42,15 +28,28 @@ export default tool({
     }
 
     const rules = loadLegacyRules(context.worktree)
-    matchLegacyRule(filePath, rules)
-
     const content = await readTool.execute({ filePath, raw: true }, context)
+    const matchedRule = matchLegacyRule(filePath, rules)
+    const strategy = chooseEditStrategy({ filePath, content, matchedRule })
     const result = applyLegacyEdit(content, args.oldString, args.newString, Boolean(args.replaceAll))
 
-    if (!result.changed) {
-      throw new Error(result.error)
+    if (result.changed) {
+      return writeTool.execute({ filePath, content: result.content }, context)
+    }
+
+    const fallbackResult = applyFallbackEditChain({
+      content,
+      oldString: args.oldString,
+      newString: args.newString,
+      detectedFamily: strategy.detectedFamily,
+    })
+
+    if (fallbackResult.changed) {
+      return writeTool.execute({ filePath, content: fallbackResult.content }, context)
     }
 
-    return writeTool.execute({ filePath, content: result.content }, context)
+    throw new Error(
+      `${result.error} | strategy=${strategy.strategy} | detected=${strategy.detectedFamily} | fallback=${strategy.fallbackMode}`,
+    )
   },
 })

package/tools/legacy-format-detector.js

@@ -0,0 +1,21 @@
+export function detectLegacyFormat(content) {
+  const normalized = content.replace(/\r\n/g, '\n')
+
+  if (/<(?:Text|Button|Img|Layout|COUNTDOWN)\|/i.test(normalized)) {
+    return { family: 'rich-ui-dsl' }
+  }
+
+  if (
+    /(using\s+[A-Z][\w.]*;|namespace\s+\w+|#include\s+[<"]|class\s+\w+\s*[{:]|public\s+(class|struct|interface))/m.test(
+      normalized,
+    )
+  ) {
+    return { family: 'general-code' }
+  }
+
+  if (/^\[@.+\]$/m.test(normalized) || /<[^<>]+\/@[^<>]+>/.test(normalized)) {
+    return { family: 'classic-tag' }
+  }
+
+  return { family: 'plain-text' }
+}

package/tools/legacy-rules-loader.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+
+import { createDefaultLegacyRules } from './legacy-router.mjs'
+import { getBundledLegacyRulesPath } from './opencode-paths.mjs'
+
+export function loadLegacyRules(worktree) {
+  return loadLegacyRulesWithMeta(worktree).rules
+}
+
+export function loadLegacyRulesWithMeta(worktree) {
+  const candidates = [
+    { filePath: path.join(worktree, '.opencode', 'legacy-rules.json'), source: 'project:.opencode' },
+    { filePath: path.join(worktree, 'legacy-rules.json'), source: 'project:root' },
+    { filePath: getBundledLegacyRulesPath(), source: 'bundled:default' },
+  ]
+
+  for (const candidate of candidates) {
+    const { filePath, source } = candidate
+    if (!existsSync(filePath)) {
+      continue
+    }
+
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'))
+    return {
+      rules: parsed.rules ?? createDefaultLegacyRules(),
+      source,
+    }
+  }
+
+  return {
+    rules: createDefaultLegacyRules(),
+    source: 'generated:fallback',
+  }
+}

package/tools/legacy-status.js

@@ -0,0 +1,51 @@
+import { tool } from '@opencode-ai/plugin'
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+
+import readTool from './read.js'
+import { matchLegacyRule } from './legacy-router.mjs'
+import { loadLegacyRulesWithMeta } from './legacy-rules-loader.js'
+import { chooseEditStrategy } from './legacy-strategy.js'
+import pkg from '../package.json' with { type: 'json' }
+
+function resolvePath(filePath, worktree) {
+  return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)
+}
+
+export default tool({
+  description: '输出当前 legacy 规则来源、命中规则与策略建议',
+  args: {
+    filePath: tool.schema.string().describe('目标文件路径'),
+  },
+  async execute(args, context) {
+    const filePath = resolvePath(args.filePath, context.worktree)
+    const { rules, source } = loadLegacyRulesWithMeta(context.worktree)
+    const matchedRule = matchLegacyRule(filePath, rules)
+
+    let content = ''
+    if (existsSync(filePath)) {
+      content = await readTool.execute({ filePath, raw: true }, context)
+    }
+
+    const strategy = chooseEditStrategy({
+      filePath,
+      content,
+      matchedRule,
+    })
+
+    return [
+      `legacy 插件版本：${pkg.version}`,
+      `文件路径：${filePath}`,
+      `规则来源：${source}`,
+      `命中规则：${matchedRule ? matchedRule.glob : '未命中'}`,
+      `格式族：${strategy.detectedFamily}`,
+      `profile：${strategy.profile}`,
+      `建议策略：${strategy.strategy}`,
+      `fallback：${strategy.fallbackMode}`,
+      `脚本文件：${strategy.isScriptLike ? '是' : '否'}`,
+      strategy.detectedFamily === 'classic-tag' ? 'classic-tag 能力：菜单行宽松匹配、标签块替换、跳转目标校验。' : '',
+      strategy.detectedFamily === 'rich-ui-dsl' ? 'rich-ui-dsl 能力：widget 字段级编辑、多行 widget 定位、children 字段保留。' : '',
+      strategy.detectedFamily === 'general-code' ? '提示：general-code 当前仅提供保守兼容，后续建议接入语法感知层。' : '提示：当前格式已接入分层编辑策略。',
+    ].join('\n')
+  },
+})

package/tools/legacy-strategy.js

@@ -0,0 +1,22 @@
+import { detectLegacyFormat } from './legacy-format-detector.js'
+
+export function chooseEditStrategy({ filePath, content, matchedRule }) {
+  const detected = detectLegacyFormat(content)
+  const markers = matchedRule?.scriptMarkers ?? []
+  const hasMarker = markers.some((marker) => content.includes(marker))
+  const looksLikeScript = hasMarker || /(^|\n)@\w+/.test(content) || content.includes('#ACT')
+  const profile = matchedRule?.profile ?? (detected.family === 'rich-ui-dsl' ? 'rich-ui-dsl' : detected.family === 'classic-tag' ? 'classic-tag' : 'default')
+  const strategy = matchedRule?.editStrategy
+    ?? (detected.family === 'rich-ui-dsl' ? 'widget-field'
+      : looksLikeScript ? 'block-first'
+      : 'exact-first')
+
+  return {
+    filePath,
+    profile,
+    detectedFamily: detected.family,
+    strategy,
+    fallbackMode: matchedRule?.fallbackMode ?? (looksLikeScript ? 'suggest-script-edit' : 'legacy-safe-replace'),
+    isScriptLike: looksLikeScript,
+  }
+}

package/tools/legacy-widget-edit.js

@@ -0,0 +1,227 @@
+function splitWidgetLine(line) {
+  if (!line.startsWith('<') || !line.endsWith('>') || !line.includes('|')) {
+    return null
+  }
+
+  const body = line.slice(1, -1)
+  const parts = body.split('|')
+  const kind = parts.shift()
+  return { kind, parts }
+}
+
+function partsToFields(parts) {
+  const fields = {}
+  for (const part of parts) {
+    const separatorIndex = part.indexOf('=')
+    if (separatorIndex === -1) {
+      continue
+    }
+    const key = part.slice(0, separatorIndex)
+    const value = part.slice(separatorIndex + 1)
+    fields[key] = value
+  }
+  return fields
+}
+
+function splitClassicMenuTokens(line) {
+  const tokens = line.match(/<[^<>]+\/@[^<>]+>/g)
+  return tokens ?? []
+}
+
+function findClassicTagBlocks(content) {
+  const lines = content.split('\n')
+  const blocks = []
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!/^\[@.+\]$/.test(lines[index].trim())) {
+      continue
+    }
+
+    let end = lines.length - 1
+    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+      if (/^\[@.+\]$/.test(lines[cursor].trim())) {
+        end = cursor - 1
+        break
+      }
+    }
+
+    blocks.push({ start: index, end, label: lines[index].trim() })
+  }
+
+  return { lines, blocks }
+}
+
+export function validateClassicTagLinks(content) {
+  const labels = new Set((content.match(/^\[@.+\]$/gm) ?? []).map((item) => item.trim()))
+  const links = content.match(/@[^>\s\]}|]+/g) ?? []
+  const missing = [...new Set(links.filter((link) => link !== '@exit' && !labels.has(`[${link}]`)))]
+  return {
+    valid: missing.length === 0,
+    missing,
+  }
+}
+
+export function updateWidgetField(line, updates) {
+  const parsed = splitWidgetLine(line)
+  if (!parsed) {
+    throw new Error('不是可识别的 widget 行')
+  }
+
+  const nextParts = parsed.parts.map((part) => {
+    const separatorIndex = part.indexOf('=')
+    if (separatorIndex === -1) {
+      return part
+    }
+
+    const key = part.slice(0, separatorIndex)
+    if (!(key in updates)) {
+      return part
+    }
+
+    return `${key}=${updates[key]}`
+  })
+
+  return `<${parsed.kind}|${nextParts.join('|')}>`
+}
+
+function updateWidgetBySignature(content, oldWidgetLine, newText) {
+  const target = splitWidgetLine(oldWidgetLine)
+  if (!target) {
+    return null
+  }
+
+  const targetFields = partsToFields(target.parts)
+  const lines = content.split('\n')
+  const hitIndex = lines.findIndex((line) => {
+    const parsed = splitWidgetLine(line)
+    if (!parsed || parsed.kind !== target.kind) {
+      return false
+    }
+
+    const fields = partsToFields(parsed.parts)
+    return ['x', 'y', 'text', 'link'].every((key) => !targetFields[key] || fields[key] === targetFields[key])
+  })
+
+  if (hitIndex === -1) {
+    return null
+  }
+
+  lines[hitIndex] = updateWidgetField(lines[hitIndex], { text: newText })
+  return lines.join('\n')
+}
+
+function updateClassicMenuLine(content, oldString, newString) {
+  const oldTokens = splitClassicMenuTokens(oldString)
+  const newTokens = splitClassicMenuTokens(newString)
+  if (oldTokens.length === 0 || oldTokens.length !== newTokens.length) {
+    return null
+  }
+
+  const lines = content.split('\n')
+  const hitIndex = lines.findIndex((line) => {
+    const lineTokens = splitClassicMenuTokens(line)
+    if (lineTokens.length !== oldTokens.length) {
+      return false
+    }
+    return oldTokens.every((token, index) => lineTokens[index] === token)
+      || oldTokens.every((token) => lineTokens.includes(token))
+  })
+
+  if (hitIndex === -1) {
+    return null
+  }
+
+  const lineTokens = splitClassicMenuTokens(lines[hitIndex])
+  let nextLine = lines[hitIndex]
+  for (let index = 0; index < oldTokens.length; index += 1) {
+    if (lineTokens.includes(oldTokens[index])) {
+      nextLine = nextLine.replace(oldTokens[index], newTokens[index])
+    }
+  }
+  lines[hitIndex] = nextLine
+  return lines.join('\n')
+}
+
+function updateClassicTagBlock(content, oldString, newString) {
+  const oldLabelMatch = oldString.match(/^\[@.+\]$/m)
+  if (!oldLabelMatch) {
+    return null
+  }
+
+  const { lines, blocks } = findClassicTagBlocks(content)
+  const target = blocks.find((block) => block.label === oldLabelMatch[0].trim())
+  if (!target) {
+    return null
+  }
+
+  const nextLines = [...lines]
+  const replacementStart = target.start + 1
+  const replacementEnd = target.end
+  nextLines.splice(replacementStart, replacementEnd - replacementStart + 1, newString)
+  return nextLines.join('\n')
+}
+
+export function applyFallbackEditChain({ content, oldString, newString, detectedFamily }) {
+  if (content.includes(oldString)) {
+    return {
+      changed: true,
+      content: content.replace(oldString, newString),
+      strategy: 'exact-first',
+    }
+  }
+
+  if (detectedFamily === 'rich-ui-dsl') {
+    const updated = updateWidgetBySignature(content, oldString, newString)
+    if (updated) {
+      return {
+        changed: true,
+        content: updated,
+        strategy: 'widget-field',
+      }
+    }
+
+    if (/<Text\|/.test(content) && content.includes(`text=${oldString}`)) {
+      return {
+        changed: true,
+        content: updateWidgetField(content, { text: newString }),
+        strategy: 'widget-field',
+      }
+    }
+  }
+
+  if (detectedFamily === 'classic-tag') {
+    const blockUpdated = updateClassicTagBlock(content, oldString, newString)
+    if (blockUpdated) {
+      return {
+        changed: true,
+        content: blockUpdated,
+        strategy: 'classic-tag-block',
+      }
+    }
+
+    const updated = updateClassicMenuLine(content, oldString, newString)
+    if (updated) {
+      return {
+        changed: true,
+        content: updated,
+        strategy: 'classic-tag-line-normalized',
+      }
+    }
+
+    const normalizedContent = content.replace(/[ \t]+/g, ' ')
+    const normalizedOld = oldString.replace(/[ \t]+/g, ' ')
+    if (normalizedContent.includes(normalizedOld)) {
+      return {
+        changed: true,
+        content: normalizedContent.replace(normalizedOld, newString),
+        strategy: 'classic-tag-line-normalized',
+      }
+    }
+  }
+
+  return {
+    changed: false,
+    content,
+    strategy: 'no-match',
+  }
+}

package/tools/read.js

@@ -1,26 +1,9 @@
 import { tool } from '@opencode-ai/plugin'
 import { readFile } from 'node:fs/promises'
-import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
-import { createDefaultLegacyRules, matchLegacyRule } from './legacy-router.mjs'
-import { getBundledLegacyRulesPath } from './opencode-paths.mjs'
+import { matchLegacyRule } from './legacy-router.mjs'
 import { decodeLegacyBuffer } from './legacy-codec.js'
-
-function loadLegacyRules(worktree) {
-  const candidates = [
-    path.join(worktree, '.opencode', 'legacy-rules.json'),
-    path.join(worktree, 'legacy-rules.json'),
-    getBundledLegacyRulesPath(),
-  ]
-
-  for (const filePath of candidates) {
-    if (existsSync(filePath)) {
-      return JSON.parse(readFileSync(filePath, 'utf8')).rules ?? createDefaultLegacyRules()
-    }
-  }
-
-  return createDefaultLegacyRules()
-}
+import { loadLegacyRules } from './legacy-rules-loader.js'
 
 function resolvePath(filePath, worktree) {
   return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)

package/tools/write.js

@@ -1,26 +1,9 @@
 import { tool } from '@opencode-ai/plugin'
 import { writeFile } from 'node:fs/promises'
-import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
-import { createDefaultLegacyRules, matchLegacyRule } from './legacy-router.mjs'
-import { getBundledLegacyRulesPath } from './opencode-paths.mjs'
+import { matchLegacyRule } from './legacy-router.mjs'
 import { encodeLegacyText } from './legacy-codec.js'
-
-function loadLegacyRules(worktree) {
-  const candidates = [
-    path.join(worktree, '.opencode', 'legacy-rules.json'),
-    path.join(worktree, 'legacy-rules.json'),
-    getBundledLegacyRulesPath(),
-  ]
-
-  for (const filePath of candidates) {
-    if (existsSync(filePath)) {
-      return JSON.parse(readFileSync(filePath, 'utf8')).rules ?? createDefaultLegacyRules()
-    }
-  }
-
-  return createDefaultLegacyRules()
-}
+import { loadLegacyRules } from './legacy-rules-loader.js'
 
 function resolvePath(filePath, worktree) {
   return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)

package/tools/edit.ts

@@ -1,64 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import { existsSync, readFileSync } from 'node:fs'
-import path from 'node:path'
-import readTool from './read.ts'
-import writeTool from './write.ts'
-import { applyLegacyEdit } from './legacy-edit-core.mjs'
-import { createDefaultLegacyRules, matchLegacyRule } from './legacy-router.mjs'
-
-function loadLegacyRules(worktree: string) {
-  const projectConfigPath = path.join(worktree, '.opencode', 'legacy-rules.json')
-  const globalConfigPath = 'C:/Users/Administrator/.config/opencode/legacy-rules.json'
-
-  if (existsSync(projectConfigPath)) {
-    return JSON.parse(readFileSync(projectConfigPath, 'utf8')).rules ?? createDefaultLegacyRules()
-  }
-
-  if (existsSync(globalConfigPath)) {
-    return JSON.parse(readFileSync(globalConfigPath, 'utf8')).rules ?? createDefaultLegacyRules()
-  }
-
-  return createDefaultLegacyRules()
-}
-
-function resolvePath(filePath: string, worktree: string) {
-  return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)
-}
-
-export default tool({
-  description: '编辑文件，命中 legacy 规则时自动按对应编码处理',
-  args: {
-    filePath: tool.schema.string().describe('文件路径'),
-    oldString: tool.schema.string().describe('要替换的旧文本'),
-    newString: tool.schema.string().describe('要写入的新文本'),
-    replaceAll: tool.schema.boolean().optional().describe('是否全部替换'),
-  },
-  async execute(args, context) {
-    const filePath = resolvePath(args.filePath, context.worktree)
-    if (!existsSync(filePath)) {
-      throw new Error(`文件不存在: ${filePath}`)
-    }
-
-    const rules = loadLegacyRules(context.worktree)
-    const matched = matchLegacyRule(filePath, rules)
-    if (matched?.tool === 'txt-gb2312') {
-      const content = await readTool.execute({ filePath, raw: true }, context)
-      const result = applyLegacyEdit(content, args.oldString, args.newString, Boolean(args.replaceAll))
-
-      if (!result.changed) {
-        throw new Error(result.error)
-      }
-
-      return writeTool.execute({ filePath, content: result.content }, context)
-    }
-
-    const content = await readTool.execute({ filePath, raw: true }, context)
-    const result = applyLegacyEdit(content, args.oldString, args.newString, Boolean(args.replaceAll))
-
-    if (!result.changed) {
-      throw new Error(result.error)
-    }
-
-    return writeTool.execute({ filePath, content: result.content }, context)
-  },
-})

package/tools/legacy.ts

@@ -1,230 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-import { tmpdir } from 'node:os'
-import { spawnSync } from 'node:child_process'
-import { applyLegacyEdit } from './legacy-edit-core.mjs'
-import { getGlobalToolPath, getKnownIconvCandidates } from './opencode-paths.mjs'
-
-let cachedNodeCommand = null
-let cachedIconvPath = null
-
-function normalizeWindowsPath(filePath) {
-  return filePath.replace(/\\/g, '/')
-}
-
-function getDerivedIconvCandidates() {
-  const pathValue = process.env.Path || process.env.PATH || ''
-  const parts = pathValue.split(';').map((item) => item.trim()).filter(Boolean)
-  const derived = []
-
-  for (const part of parts) {
-    const normalized = normalizeWindowsPath(part)
-    if (normalized.toLowerCase().endsWith('/git/cmd')) {
-      derived.push(normalized.replace(/\/cmd$/i, '/usr/bin/iconv.exe'))
-    }
-  }
-
-  return derived
-}
-
-function resolveTxtToolPath(context) {
-  const projectToolPath = path.join(context.worktree, 'tools', 'txt-gb2312-tool.mjs')
-  if (existsSync(projectToolPath)) {
-    return projectToolPath
-  }
-
-  return getGlobalToolPath('txt-gb2312-tool.mjs')
-}
-
-function resolveNodeCommand() {
-  if (cachedNodeCommand) {
-    return cachedNodeCommand
-  }
-
-  const candidates = [process.env.OPENCODE_NODE_PATH, process.execPath, 'node'].filter(Boolean)
-
-  for (const candidate of candidates) {
-    const probe = spawnSync(candidate, ['-e', 'process.stdout.write(process.release?.name === "node" ? "node-ok" : "not-node")'], {
-      encoding: 'utf8',
-    })
-    const output = `${probe.stdout || ''}${probe.stderr || ''}`.trim()
-    if (probe.status === 0 && output === 'node-ok') {
-      cachedNodeCommand = candidate
-      return cachedNodeCommand
-    }
-  }
-
-  throw new Error('未找到可用的 Node.js 命令，无法执行 txt-gb2312-tool.mjs')
-}
-
-function resolveIconvPath() {
-  if (cachedIconvPath) {
-    return cachedIconvPath
-  }
-
-  const candidates = [
-    'iconv',
-    process.env.OPENCODE_ICONV_PATH,
-    process.env.ICONV_PATH,
-    ...getKnownIconvCandidates(),
-    ...getDerivedIconvCandidates(),
-  ].filter(Boolean)
-
-  for (const candidate of candidates) {
-    const probe = spawnSync(candidate, ['--version'], { encoding: 'utf8' })
-    if (probe.status === 0) {
-      cachedIconvPath = candidate
-      return cachedIconvPath
-    }
-  }
-
-  throw new Error('iconv 不可用，无法处理 legacy 文件')
-}
-
-function runNode(scriptArgs, cwd, extraEnv = {}) {
-  const nodeCommand = resolveNodeCommand()
-  const result = spawnSync(nodeCommand, scriptArgs, {
-    cwd,
-    encoding: 'utf8',
-    env: { ...process.env, ...extraEnv },
-  })
-
-  if (result.status !== 0) {
-    const stderr = (result.stderr || '').trim()
-    const stdout = (result.stdout || '').trim()
-    throw new Error(
-      [
-        'legacy 工具执行失败',
-        `nodeCommand=${nodeCommand}`,
-        `cwd=${cwd}`,
-        `status=${result.status}`,
-        `stderr=${stderr || '<empty>'}`,
-        `stdout=${stdout || '<empty>'}`,
-      ].join(' | '),
-    )
-  }
-
-  return result.stdout
-}
-
-function runIconv(iconvPath, args) {
-  const result = spawnSync(iconvPath, args, { encoding: 'buffer' })
-  if (result.status !== 0) {
-    throw new Error(result.stderr?.toString('utf8') || 'iconv 执行失败')
-  }
-  return result.stdout
-}
-
-function readGb2312File(filePath) {
-  const iconvPath = resolveIconvPath()
-  const output = runIconv(iconvPath, ['-f', 'GB2312', '-t', 'UTF-8', filePath])
-  return output.toString('utf8')
-}
-
-export const read = tool({
-  description: '按 legacy 编码读取文件',
-  args: {
-    filePath: tool.schema.string().describe('文件路径'),
-    encoding: tool.schema.string().describe('legacy 编码'),
-    strict: tool.schema.boolean().describe('是否严格模式'),
-  },
-  async execute(args, context) {
-    const filePath = path.isAbsolute(args.filePath)
-      ? args.filePath
-      : path.join(context.worktree, args.filePath)
-
-    if (args.encoding.toLowerCase() === 'gb2312') {
-      return readGb2312File(filePath)
-    }
-
-    const iconvPath = resolveIconvPath()
-    const output = runIconv(iconvPath, ['-f', args.encoding, '-t', 'UTF-8', filePath])
-    return output.toString('utf8')
-  },
-})
-
-export const write = tool({
-  description: '按 legacy 编码写入文件',
-  args: {
-    filePath: tool.schema.string().describe('文件路径'),
-    content: tool.schema.string().describe('UTF-8 内容'),
-    encoding: tool.schema.string().describe('legacy 编码'),
-    strict: tool.schema.boolean().describe('是否严格模式'),
-  },
-  async execute(args, context) {
-    const filePath = path.isAbsolute(args.filePath)
-      ? args.filePath
-      : path.join(context.worktree, args.filePath)
-
-    const tempDir = await mkdtemp(path.join(tmpdir(), 'legacy-write-'))
-    const tempPath = path.join(tempDir, 'content.utf8')
-
-    try {
-      await writeFile(tempPath, args.content, 'utf8')
-
-      if (args.encoding.toLowerCase() === 'gb2312') {
-        const iconvPath = resolveIconvPath()
-        return runNode([resolveTxtToolPath(context), 'write', filePath, tempPath], context.worktree, {
-          OPENCODE_ICONV_PATH: iconvPath,
-          ICONV_PATH: iconvPath,
-        })
-      }
-
-      const iconvPath = resolveIconvPath()
-      const converted = runIconv(iconvPath, ['-f', 'UTF-8', '-t', args.encoding, tempPath])
-      await writeFile(filePath, converted)
-      return `已按 ${args.encoding} 编码写入 ${filePath}`
-    } finally {
-      await rm(tempDir, { recursive: true, force: true })
-    }
-  },
-})
-
-export const edit = tool({
-  description: '按 legacy 编码编辑文件',
-  args: {
-    filePath: tool.schema.string().describe('文件路径'),
-    oldString: tool.schema.string().describe('要替换的旧文本'),
-    newString: tool.schema.string().describe('要写入的新文本'),
-    replaceAll: tool.schema.boolean().describe('是否全部替换'),
-    encoding: tool.schema.string().describe('legacy 编码'),
-    strict: tool.schema.boolean().describe('是否严格模式'),
-  },
-  async execute(args, context) {
-    const filePath = path.isAbsolute(args.filePath)
-      ? args.filePath
-      : path.join(context.worktree, args.filePath)
-
-    if (!existsSync(filePath)) {
-      throw new Error(`文件不存在: ${filePath}`)
-    }
-
-    const content = await read.execute(
-      {
-        filePath,
-        encoding: args.encoding,
-        strict: args.strict,
-        raw: true,
-      },
-      context,
-    )
-
-    const result = applyLegacyEdit(content, args.oldString, args.newString, Boolean(args.replaceAll))
-
-    if (!result.changed) {
-      throw new Error(result.error)
-    }
-
-    return write.execute(
-      {
-        filePath,
-        content: result.content,
-        encoding: args.encoding,
-        strict: args.strict,
-      },
-      context,
-    )
-  },
-})

package/tools/read.ts

@@ -1,213 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import { readFile } from 'node:fs/promises'
-import { existsSync, readFileSync } from 'node:fs'
-import path from 'node:path'
-import { spawnSync } from 'node:child_process'
-import { createDefaultLegacyRules, matchLegacyRule } from './legacy-router.mjs'
-import { getGlobalLegacyRulesPath, getKnownIconvCandidates } from './opencode-paths.mjs'
-
-let cachedIconvPath = null
-
-function loadLegacyRules(worktree) {
-  const projectConfigPath = path.join(worktree, '.opencode', 'legacy-rules.json')
-  const globalConfigPath = getGlobalLegacyRulesPath()
-
-  if (existsSync(projectConfigPath)) {
-    return JSON.parse(readFileSync(projectConfigPath, 'utf8')).rules ?? createDefaultLegacyRules()
-  }
-
-  if (existsSync(globalConfigPath)) {
-    return JSON.parse(readFileSync(globalConfigPath, 'utf8')).rules ?? createDefaultLegacyRules()
-  }
-
-  return createDefaultLegacyRules()
-}
-
-function resolvePath(filePath, worktree) {
-  return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)
-}
-
-function normalizeWindowsPath(filePath) {
-  return filePath.replace(/\\/g, '/')
-}
-
-function getDerivedIconvCandidates() {
-  const pathValue = process.env.Path || process.env.PATH || ''
-  const parts = pathValue.split(';').map((item) => item.trim()).filter(Boolean)
-  const derived = []
-
-  for (const part of parts) {
-    const normalized = normalizeWindowsPath(part)
-    if (normalized.toLowerCase().endsWith('/git/cmd')) {
-      derived.push(normalized.replace(/\/cmd$/i, '/usr/bin/iconv.exe'))
-    }
-  }
-
-  return derived
-}
-
-function resolveIconvPath() {
-  if (cachedIconvPath) {
-    return cachedIconvPath
-  }
-
-  const candidates = [
-    'iconv',
-    process.env.OPENCODE_ICONV_PATH,
-    process.env.ICONV_PATH,
-    ...getKnownIconvCandidates(),
-    ...getDerivedIconvCandidates(),
-  ].filter(Boolean)
-
-  for (const candidate of candidates) {
-    const probe = spawnSync(candidate, ['--version'], { encoding: 'utf8' })
-    if (probe.status === 0) {
-      cachedIconvPath = candidate
-      return cachedIconvPath
-    }
-  }
-
-  throw new Error('iconv 不可用，无法处理 legacy 文件读取')
-}
-
-function applyOffsetLimit(content, offset, limit) {
-  if (offset === undefined && limit === undefined) {
-    return content
-  }
-
-  if (offset !== undefined && offset < 1) {
-    throw new Error('offset must be greater than or equal to 1')
-  }
-
-  const lines = content.split(/\r?\n/)
-  const start = offset ? offset - 1 : 0
-  const end = limit ? start + limit : lines.length
-  return lines.slice(start, end).join('\n')
-}
-
-function applyOffsetLimitFast(content, offset, limit) {
-  if (offset === undefined && limit === undefined) {
-    return content
-  }
-
-  if (offset !== undefined && offset < 1) {
-    throw new Error('offset must be greater than or equal to 1')
-  }
-
-  const targetStartLine = offset || 1
-  const targetLineCount = limit || Number.MAX_SAFE_INTEGER
-  const targetEndLine = targetStartLine + targetLineCount - 1
-
-  let lineNumber = 1
-  let currentStart = 0
-  let sliceStart = -1
-  let sliceEnd = content.length
-
-  for (let index = 0; index < content.length; index += 1) {
-    const ch = content[index]
-    if (ch !== '\n') {
-      continue
-    }
-
-    if (lineNumber === targetStartLine) {
-      sliceStart = currentStart
-    }
-
-    if (lineNumber === targetEndLine) {
-      sliceEnd = index
-      break
-    }
-
-    lineNumber += 1
-    currentStart = index + 1
-  }
-
-  if (sliceStart === -1) {
-    if (lineNumber === targetStartLine) {
-      sliceStart = currentStart
-    } else {
-      return ''
-    }
-  }
-
-  const result = content.slice(sliceStart, sliceEnd)
-  return result.endsWith('\r') ? result.slice(0, -1) : result
-}
-
-function readGb2312File(filePath, offset, limit) {
-  const iconvPath = resolveIconvPath()
-  const result = spawnSync(iconvPath, ['-f', 'GB2312', '-t', 'UTF-8', filePath], {
-    encoding: 'utf8',
-  })
-
-  if (result.status !== 0) {
-    throw new Error(result.stderr || 'legacy txt 读取失败')
-  }
-
-  return applyOffsetLimitFast(result.stdout, offset, limit)
-}
-
-function withLargeFileNotice(content, offset, limit) {
-  if (offset === undefined && limit === undefined) {
-    return content
-  }
-
-  return [
-    '--- 读取回执 ---',
-    `读取方式：分段读取`,
-    `起始行号：${offset ?? 1}`,
-    `读取行数：${limit ?? 'all'}`,
-    '说明：如需继续读取剩余内容，请继续增大 offset。',
-    content,
-  ].join('\n')
-}
-
-function withLegacyReadNotice(content, matched, offset, limit, raw = false) {
-  if (raw) {
-    return content
-  }
-
-  const lines = [
-    '--- Legacy 读取回执 ---',
-    `编码：${matched?.encoding || 'unknown'}`,
-    `处理器：${matched?.tool || 'legacy-text'}`,
-    `严格模式：${matched?.strict === true ? 'true' : 'false'}`,
-  ]
-
-  if (offset !== undefined || limit !== undefined) {
-    lines.push(`读取方式：分段读取`)
-    lines.push(`起始行号：${offset ?? 1}`)
-    lines.push(`读取行数：${limit ?? 'all'}`)
-    lines.push('说明：如需继续读取剩余内容，请继续增大 offset。')
-  } else {
-    lines.push('读取方式：完整读取')
-  }
-
-  lines.push(content)
-  return lines.join('\n')
-}
-
-export default tool({
-  description: '读取文件，命中 legacy 规则时自动按对应编码处理',
-  args: {
-    filePath: tool.schema.string().describe('文件路径'),
-    offset: tool.schema.number().optional().describe('起始行号，1 开始'),
-    limit: tool.schema.number().optional().describe('最多读取多少行'),
-    raw: tool.schema.boolean().optional().describe('内部调用时返回原始内容'),
-  },
-  async execute(args, context) {
-    const filePath = resolvePath(args.filePath, context.worktree)
-    const rules = loadLegacyRules(context.worktree)
-    const matched = matchLegacyRule(filePath, rules)
-
-    if (matched?.tool === 'txt-gb2312' || matched?.encoding?.toLowerCase() === 'gb2312') {
-      return withLegacyReadNotice(readGb2312File(filePath, args.offset, args.limit), matched, args.offset, args.limit, Boolean(args.raw))
-    }
-
-    const content = await readFile(filePath, 'utf8')
-    if (args.raw) {
-      return applyOffsetLimitFast(content, args.offset, args.limit)
-    }
-    return withLargeFileNotice(applyOffsetLimitFast(content, args.offset, args.limit), args.offset, args.limit)
-  },
-})

package/tools/script-edit.ts

@@ -1,59 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import { existsSync } from 'node:fs'
-import path from 'node:path'
-import readTool from './read.ts'
-import writeTool from './write.ts'
-import {
-  insertAfterAnchor,
-  insertIntoLabelAfterMarker,
-  replaceLabelBlock,
-} from './script-edit-core.mjs'
-
-function resolvePath(filePath, worktree) {
-  return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)
-}
-
-export default tool({
-  description: '按标签块或锚点编辑脚本类文本，适合 legacy 脚本文件',
-  args: {
-    filePath: tool.schema.string().describe('文件路径'),
-    mode: tool.schema.enum(['insert_after_anchor', 'insert_into_label_after_marker', 'replace_label_block']).describe('编辑模式'),
-    label: tool.schema.string().optional().describe('目标标签名，例如 @全体补偿页面'),
-    marker: tool.schema.string().optional().describe('标签块内锚点行，例如 #ACT'),
-    anchor: tool.schema.string().optional().describe('普通锚点文本'),
-    content: tool.schema.string().describe('要插入或替换的内容'),
-  },
-  async execute(args, context) {
-    const filePath = resolvePath(args.filePath, context.worktree)
-
-    if (!existsSync(filePath)) {
-      throw new Error(`文件不存在: ${filePath}`)
-    }
-
-    const original = await readTool.execute({ filePath, raw: true }, context)
-    let next = original
-
-    if (args.mode === 'insert_after_anchor') {
-      if (!args.anchor) {
-        throw new Error('insert_after_anchor 模式缺少 anchor')
-      }
-      next = insertAfterAnchor(original, args.anchor, args.content)
-    }
-
-    if (args.mode === 'insert_into_label_after_marker') {
-      if (!args.label || !args.marker) {
-        throw new Error('insert_into_label_after_marker 模式缺少 label 或 marker')
-      }
-      next = insertIntoLabelAfterMarker(original, args.label, args.marker, args.content)
-    }
-
-    if (args.mode === 'replace_label_block') {
-      if (!args.label) {
-        throw new Error('replace_label_block 模式缺少 label')
-      }
-      next = replaceLabelBlock(original, args.label, args.content)
-    }
-
-    return writeTool.execute({ filePath, content: next }, context)
-  },
-})

package/tools/write.ts

@@ -1,67 +0,0 @@
-import { tool } from '@opencode-ai/plugin'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { existsSync, readFileSync } from 'node:fs'
-import path from 'node:path'
-import { tmpdir } from 'node:os'
-import { spawnSync } from 'node:child_process'
-import { createDefaultLegacyRules, matchLegacyRule } from './legacy-router.mjs'
-import { getGlobalLegacyRulesPath, getGlobalToolPath } from './opencode-paths.mjs'
-
-function loadLegacyRules(worktree: string) {
-  const projectConfigPath = path.join(worktree, '.opencode', 'legacy-rules.json')
-  const globalConfigPath = getGlobalLegacyRulesPath()
-
-  if (existsSync(projectConfigPath)) {
-    return JSON.parse(readFileSync(projectConfigPath, 'utf8')).rules ?? createDefaultLegacyRules()
-  }
-
-  if (existsSync(globalConfigPath)) {
-    return JSON.parse(readFileSync(globalConfigPath, 'utf8')).rules ?? createDefaultLegacyRules()
-  }
-
-  return createDefaultLegacyRules()
-}
-
-function resolvePath(filePath: string, worktree: string) {
-  return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)
-}
-
-function writeViaTxtTool(targetPath: string, content: string, worktree: string) {
-  const toolPath = getGlobalToolPath('txt-gb2312-tool.mjs')
-  return mkdtemp(path.join(tmpdir(), 'global-write-')).then(async (tempDir) => {
-    const tempPath = path.join(tempDir, 'content.utf8')
-    try {
-      await writeFile(tempPath, content, 'utf8')
-      const result = spawnSync(process.execPath, [toolPath, 'write', targetPath, tempPath], {
-        cwd: worktree,
-        encoding: 'utf8',
-      })
-      if (result.status !== 0) {
-        throw new Error(result.stderr || 'legacy txt 写入失败')
-      }
-      return result.stdout
-    } finally {
-      await rm(tempDir, { recursive: true, force: true })
-    }
-  })
-}
-
-export default tool({
-  description: '写入文件，命中 legacy 规则时自动按对应编码处理',
-  args: {
-    filePath: tool.schema.string().describe('文件路径'),
-    content: tool.schema.string().describe('文件内容'),
-  },
-  async execute(args, context) {
-    const filePath = resolvePath(args.filePath, context.worktree)
-    const rules = loadLegacyRules(context.worktree)
-    const matched = matchLegacyRule(filePath, rules)
-
-    if (matched?.tool === 'txt-gb2312' || matched?.encoding?.toLowerCase() === 'gb2312') {
-      return writeViaTxtTool(filePath, args.content, context.worktree)
-    }
-
-    await writeFile(filePath, args.content, 'utf8')
-    return `已写入 ${filePath}`
-  },
-})