@movemama/opencode-legacy 0.1.1 → 1.0.1

package/README.md

@@ -4,6 +4,25 @@ OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt`
 
 当前主链路已经改为纯 JS 编码实现，不再依赖系统外部 `iconv.exe`。
 
+## 规则注入
+
+插件现在会在每轮对话自动读取并注入以下规则文件：
+
+1. 全局 `AGENTS.md`：根据当前环境变量 `USERPROFILE` 或 `HOME` 动态解析到 `~/.config/opencode/AGENTS.md`
+2. 项目 `AGENTS.md`：根据当前打开项目的 `worktree` 动态解析到 `<worktree>/AGENTS.md`
+
+注入后的硬规则会进入系统上下文，用于约束代理优先读取规则、完整读取目标文件、以及统一输出回执。
+
+另外，插件已为以下编辑类工具增加前置守卫：
+
+- `edit`
+- `write`
+- `script-edit`
+- `legacy_edit`
+- `legacy_write`
+
+如果当前会话尚未完成 `AGENTS.md` 规则注入，上述工具会直接拒绝执行，以避免代理在未读取规则的情况下改文件。
+
 ## 安装
 
 在 OpenCode 配置中加入：
@@ -58,8 +77,24 @@ OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt`
 当前 `edit` 已经接入自动策略层。
 
 - 普通文本默认走 `exact-first`
-- 脚本型文本可根据 `profile` 和 `scriptMarkers` 判断为 `block-first`
-- 失败时会返回当前策略和 fallback 提示，便于继续排障
+- `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# / 强语法代码文本
+  - 当前仅做安全识别与保守回退，不做激进结构改写
 
 ## 诊断工具
 
@@ -68,6 +103,7 @@ OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt`
 - 插件版本
 - 规则来源
 - 命中规则
+- 格式族
 - profile
 - 建议策略
 - fallback 模式
@@ -87,6 +123,20 @@ OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt`
 
 也可以直接调用 `legacy_status` 检查当前文件会命中哪条规则、建议使用哪种策略。
 
+如果检测为 `general-code`，当前插件会优先保持保守，不会像 rich-ui / classic-tag 那样做特化结构修改；这部分为未来语法感知层预留空间。
+
+如果检测为 `classic-tag`，当前插件已能在 exact 失败后继续尝试：
+
+- 菜单行 token 级匹配
+- 标签块局部替换
+- 跳转标签存在性检查
+
+如果检测为 `rich-ui-dsl`，当前插件已能在 exact 失败后继续尝试：
+
+- widget 字段级更新
+- 多行 widget 定位
+- 保留 `children={...}` 容器字段
+
 ## 兼容说明
 
 - `txt-gb2312-tool.mjs` 目前仅保留为兼容遗留文件，不再是主链路依赖

package/index.js

@@ -4,18 +4,27 @@ 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'
+import { createAgentsRuleHooks } from './tools/agents-rules.js'
 
-export const OpenCodeLegacyPlugin = async () => ({
-  tool: {
-    read: readTool,
-    write: writeTool,
-    edit: editTool,
-    'script-edit': scriptEditTool,
-    legacy_read: legacyReadTool,
-    legacy_write: legacyWriteTool,
-    legacy_edit: legacyEditTool,
-    legacy_status: legacyStatusTool,
-  },
-})
+export const OpenCodeLegacyPlugin = async (context, options = {}) => {
+  const agentsRuleHooks = createAgentsRuleHooks({
+    worktree: context.worktree,
+    globalAgentsPath: options.globalAgentsPath,
+  })
+
+  return {
+    tool: {
+      read: readTool,
+      write: writeTool,
+      edit: editTool,
+      'script-edit': scriptEditTool,
+      legacy_read: legacyReadTool,
+      legacy_write: legacyWriteTool,
+      legacy_edit: legacyEditTool,
+      legacy_status: legacyStatusTool,
+    },
+    ...agentsRuleHooks,
+  }
+}
 
 export default OpenCodeLegacyPlugin

package/legacy-rules.json

@@ -12,6 +12,17 @@
       "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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@movemama/opencode-legacy",
-  "version": "0.1.1",
+  "version": "1.0.1",
   "description": "OpenCode legacy text processing plugin for GB2312 and script-safe editing workflows.",
   "type": "module",
   "main": "./index.js",

package/plugin-meta.js

@@ -10,5 +10,6 @@ export function getPluginMeta() {
       'legacy_write',
       'legacy_edit',
     ],
+    hookNames: ['experimental.chat.system.transform', 'tool.execute.before'],
   }
 }

package/tools/agents-rules.js

@@ -0,0 +1,76 @@
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+
+const EDIT_GUARDED_TOOLS = new Set(['edit', 'write', 'script-edit', 'legacy_edit', 'legacy_write'])
+
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, '\n').trim()
+}
+
+function getDefaultGlobalAgentsPath() {
+  const home = process.env.USERPROFILE || process.env.HOME || ''
+  return path.join(home, '.config', 'opencode', 'AGENTS.md')
+}
+
+function readAgentsFileIfExists(filePath) {
+  if (!filePath || !existsSync(filePath)) {
+    return null
+  }
+
+  return normalizeLineEndings(readFileSync(filePath, 'utf8'))
+}
+
+function buildInjectedRulesBlock(entries) {
+  const sections = entries
+    .filter((entry) => entry.content)
+    .map((entry) => [`## ${entry.label}`, entry.content].join('\n'))
+
+  return [
+    '[AGENTS Rules Bootstrap]',
+    '你必须在本轮严格遵守以下规则优先级：系统 > 开发者 > 全局 AGENTS.md > 项目 AGENTS.md > 用户临时偏好。',
+    '硬性要求：分析或编辑前先读取规则与目标文件完整内容；文件过长时连续分段读取；上下文不足前不得做结构判断或编辑判断。',
+    '硬性要求：所有用户可见输出必须使用简体中文；受限时必须说明受限原因、影响范围、备选方案；回复末尾必须输出规则执行回执。',
+    ...sections,
+  ].join('\n\n')
+}
+
+export function createAgentsRuleHooks(input = {}) {
+  const globalAgentsPath = input.globalAgentsPath || getDefaultGlobalAgentsPath()
+  const projectAgentsPath = path.join(input.worktree, 'AGENTS.md')
+  const sessionBootstrapState = new Set()
+
+  function loadRules() {
+    return [
+      {
+        label: 'Global AGENTS.md',
+        path: globalAgentsPath,
+        content: readAgentsFileIfExists(globalAgentsPath),
+      },
+      {
+        label: 'Project AGENTS.md',
+        path: projectAgentsPath,
+        content: readAgentsFileIfExists(projectAgentsPath),
+      },
+    ]
+  }
+
+  return {
+    'experimental.chat.system.transform': async (hookInput, output) => {
+      const entries = loadRules()
+      const injected = buildInjectedRulesBlock(entries)
+      output.system.push(injected)
+      if (hookInput?.sessionID) {
+        sessionBootstrapState.add(hookInput.sessionID)
+      }
+    },
+    'tool.execute.before': async (hookInput) => {
+      if (!EDIT_GUARDED_TOOLS.has(hookInput.tool)) {
+        return
+      }
+
+      if (!sessionBootstrapState.has(hookInput.sessionID)) {
+        throw new Error('当前会话尚未完成 AGENTS.md 规则注入，已禁止编辑类工具执行。请先让插件读取全局与项目 AGENTS.md。')
+      }
+    },
+  }
+}

package/tools/edit.js

@@ -7,6 +7,7 @@ import { applyLegacyEdit } from './legacy-edit-core.mjs'
 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)
@@ -32,10 +33,23 @@ export default tool({
     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} | strategy=${strategy.strategy} | fallback=${strategy.fallbackMode}`)
+    if (result.changed) {
+      return writeTool.execute({ filePath, content: result.content }, context)
     }
 
-    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)
+    }
+
+    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-status.js

@@ -38,10 +38,14 @@ export default tool({
       `文件路径：${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

@@ -1,12 +1,21 @@
+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: matchedRule?.profile ?? 'default',
-    strategy: matchedRule?.editStrategy ?? (looksLikeScript ? 'block-first' : 'exact-first'),
+    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',
+  }
+}