@movemama/opencode-legacy 0.1.0

package/README.md

@@ -0,0 +1,53 @@
+# @movemama/opencode-legacy
+
+OpenCode legacy 文本处理插件，面向 `GB2312` 文本、脚本型 `.txt` 编辑和 legacy 规则路由场景。
+
+## 安装
+
+在 OpenCode 配置中加入：
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "@movemama/opencode-legacy@latest"
+  ]
+}
+```
+
+首次未安装的用户会在 OpenCode 启动时自动安装当前 `latest` 版本。后续更新可由用户自行处理。
+
+## 当前提供的工具
+
+- `read`
+- `write`
+- `edit`
+- `script-edit`
+- `legacy_read`
+- `legacy_write`
+- `legacy_edit`
+
+其中同名工具 `read`、`write`、`edit` 会覆盖 OpenCode 内置工具，实现 legacy 路由。
+
+## 规则文件
+
+包内自带 `legacy-rules.json` 作为默认规则。
+
+加载优先级：
+
+1. `<worktree>/.opencode/legacy-rules.json`
+2. `<worktree>/legacy-rules.json`
+3. 包内 `legacy-rules.json`
+
+## 发布
+
+```bash
+npm login
+npm publish --access public
+```
+
+## 开发测试
+
+```bash
+npm test
+```

package/index.js

@@ -0,0 +1,19 @@
+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 { edit as legacyEditTool, read as legacyReadTool, write as legacyWriteTool } from './tools/legacy.js'
+
+export const OpenCodeLegacyPlugin = async () => ({
+  tool: {
+    read: readTool,
+    write: writeTool,
+    edit: editTool,
+    'script-edit': scriptEditTool,
+    legacy_read: legacyReadTool,
+    legacy_write: legacyWriteTool,
+    legacy_edit: legacyEditTool,
+  },
+})
+
+export default OpenCodeLegacyPlugin

package/legacy-rules.json

@@ -0,0 +1,19 @@
+{
+  "_comment": "rules 为实际生效规则；examples 为示例模板，不会自动生效。新增文件类型时，优先复制 examples 中最接近的一条到 rules。tool 可选值当前建议使用 txt-gb2312 或 legacy-text。",
+  "rules": [
+    {
+      "glob": "**/*.txt",
+      "encoding": "gb2312",
+      "strict": true,
+      "tool": "txt-gb2312",
+      "priority": 10
+    },
+    {
+      "glob": "**/*.{ini,cfg,dat}",
+      "encoding": "gbk",
+      "strict": false,
+      "tool": "legacy-text",
+      "priority": 1
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@movemama/opencode-legacy",
+  "version": "0.1.0",
+  "description": "OpenCode legacy text processing plugin for GB2312 and script-safe editing workflows.",
+  "type": "module",
+  "main": "./index.js",
+  "exports": "./index.js",
+  "files": [
+    "index.js",
+    "plugin-meta.js",
+    "legacy-rules.json",
+    "tools",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test tests/*.test.mjs"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "legacy",
+    "gb2312",
+    "iconv"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "1.3.3",
+    "iconv-lite": "^0.7.0"
+  }
+}

package/plugin-meta.js

@@ -0,0 +1,14 @@
+export function getPluginMeta() {
+  return {
+    packageName: '@movemama/opencode-legacy',
+    toolNames: [
+      'read',
+      'write',
+      'edit',
+      'script-edit',
+      'legacy_read',
+      'legacy_write',
+      'legacy_edit',
+    ],
+  }
+}

package/tools/edit.js

@@ -0,0 +1,56 @@
+import { tool } from '@opencode-ai/plugin'
+import { existsSync, readFileSync } 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()
+}
+
+function resolvePath(filePath, worktree) {
+  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)
+    matchLegacyRule(filePath, rules)
+
+    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/edit.ts

@@ -0,0 +1,64 @@
+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/grep.js

@@ -0,0 +1,210 @@
+import { tool } from '@opencode-ai/plugin'
+import { readdir, 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 { searchContentLines, searchContentLinesChunked } from './legacy-search-core.mjs'
+import { getGlobalLegacyRulesPath, getGlobalToolPath } from './opencode-paths.mjs'
+
+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(inputPath, worktree) {
+  if (!inputPath || inputPath === '.') {
+    return worktree
+  }
+  return path.isAbsolute(inputPath) ? inputPath : path.join(worktree, inputPath)
+}
+
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, '/')
+}
+
+function globToRegExp(glob) {
+  const normalized = normalizePath(glob)
+  let pattern = '^'
+
+  for (let index = 0; index < normalized.length; index += 1) {
+    const ch = normalized[index]
+    if (ch === '*') {
+      const next = normalized[index + 1]
+      if (next === '*') {
+        pattern += '.*'
+        index += 1
+      } else {
+        pattern += '[^/]*'
+      }
+      continue
+    }
+    if (ch === '?') {
+      pattern += '.'
+      continue
+    }
+    if (ch === '{') {
+      const closeIndex = normalized.indexOf('}', index)
+      if (closeIndex > index) {
+        const group = normalized
+          .slice(index + 1, closeIndex)
+          .split(',')
+          .map((part) => part.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+          .join('|')
+        pattern += `(${group})`
+        index = closeIndex
+        continue
+      }
+    }
+    if ('\\.[]{}()+-^$|'.includes(ch)) {
+      pattern += `\\${ch}`
+      continue
+    }
+    pattern += ch
+  }
+
+  pattern += '$'
+  return new RegExp(pattern, 'i')
+}
+
+async function collectFiles(rootPath, includePattern) {
+  const results = []
+  const includeRegex = includePattern ? globToRegExp(includePattern) : null
+
+  async function walk(currentPath) {
+    const entries = await readdir(currentPath, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = path.join(currentPath, entry.name)
+      if (entry.isDirectory()) {
+        await walk(fullPath)
+        continue
+      }
+
+      const normalized = normalizePath(fullPath)
+      if (!includeRegex || includeRegex.test(normalized)) {
+        results.push(fullPath)
+      }
+    }
+  }
+
+  if (existsSync(rootPath) && path.extname(rootPath)) {
+    if (!includeRegex || includeRegex.test(normalizePath(rootPath))) {
+      return [rootPath]
+    }
+    return []
+  }
+
+  await walk(rootPath)
+  return results
+}
+
+function readViaTxtTool(filePath, worktree) {
+  const toolPath = getGlobalToolPath('txt-gb2312-tool.mjs')
+  const result = spawnSync(process.execPath, [toolPath, 'read', filePath], {
+    cwd: worktree,
+    encoding: 'utf8',
+  })
+
+  if (result.status !== 0) {
+    throw new Error(result.stderr || 'legacy txt 搜索读取失败')
+  }
+
+  return result.stdout
+}
+
+async function readSearchableContent(filePath, matched, worktree) {
+  if (matched?.tool === 'txt-gb2312' || matched?.encoding?.toLowerCase() === 'gb2312') {
+    return readViaTxtTool(filePath, worktree)
+  }
+
+  return readFile(filePath, 'utf8')
+}
+
+function searchLargeAware(content, pattern, options = {}) {
+  const threshold = options.chunkThreshold || 1024 * 1024
+  if (content.length > threshold) {
+    return searchContentLinesChunked(content, pattern, options)
+  }
+  return searchContentLines(content, pattern, options)
+}
+
+export default tool({
+  description: '搜索文件内容，命中 legacy 规则时按对应编码读取后再搜索',
+  args: {
+    path: tool.schema.string().optional().describe('搜索根路径'),
+    pattern: tool.schema.string().describe('搜索模式'),
+    include: tool.schema.string().optional().describe('文件 glob 过滤'),
+    caseSensitive: tool.schema.boolean().optional().describe('是否区分大小写'),
+    fixedStrings: tool.schema.boolean().optional().describe('是否按普通字符串匹配'),
+    wholeWord: tool.schema.boolean().optional().describe('是否按整词匹配'),
+    maxResults: tool.schema.number().optional().describe('最多返回多少条命中结果'),
+    page: tool.schema.number().optional().describe('结果页码，从 1 开始'),
+  },
+  async execute(args, context) {
+    const rules = loadLegacyRules(context.worktree)
+    const rootPath = resolvePath(args.path || '.', context.worktree)
+    const files = await collectFiles(rootPath, args.include)
+    const outputs = []
+    const maxResults = args.maxResults || 200
+    const page = args.page || 1
+    const startIndex = (page - 1) * maxResults
+    const endIndex = startIndex + maxResults
+    let seen = 0
+
+    for (const filePath of files) {
+      const matched = matchLegacyRule(filePath, rules)
+      const content = await readSearchableContent(filePath, matched, context.worktree)
+      const matches = searchLargeAware(content, args.pattern, {
+        caseSensitive: Boolean(args.caseSensitive),
+        fixedStrings: Boolean(args.fixedStrings),
+        wholeWord: Boolean(args.wholeWord),
+        chunkThreshold: 1024 * 512,
+        chunkSize: 1024 * 256,
+      })
+
+      for (const item of matches) {
+        if (seen >= startIndex && outputs.length < maxResults) {
+          outputs.push(`${filePath}:${item.line}:${item.text}`)
+        }
+        seen += 1
+        if (seen >= endIndex) {
+          if (outputs.length >= maxResults) {
+            return [
+              '--- 搜索回执 ---',
+              `页码：${page}`,
+              `每页上限：${maxResults}`,
+              `本页结果数：${outputs.length}`,
+              `已达到本页上限，请增大 page 查看后续结果。`,
+              ...outputs,
+            ].join('\n')
+          }
+          return [
+            '--- 搜索回执 ---',
+            `页码：${page}`,
+            `每页上限：${maxResults}`,
+            `本页结果数：${outputs.length}`,
+            ...outputs,
+          ].join('\n')
+        }
+      }
+    }
+
+    return [
+      '--- 搜索回执 ---',
+      `页码：${page}`,
+      `每页上限：${maxResults}`,
+      `本页结果数：${outputs.length}`,
+      ...outputs,
+    ].join('\n')
+  },
+})

package/tools/legacy-codec.js

@@ -0,0 +1,13 @@
+import iconv from 'iconv-lite'
+
+export function decodeLegacyBuffer(buffer, encoding) {
+  return iconv.decode(buffer, encoding)
+}
+
+export function encodeLegacyText(text, encoding) {
+  return iconv.encode(text, encoding)
+}
+
+export function encodingExists(encoding) {
+  return iconv.encodingExists(encoding)
+}

package/tools/legacy-edit-core.mjs

@@ -0,0 +1,134 @@
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, '\n')
+}
+
+function trimRightSpaces(text) {
+  return text.replace(/[ \t]+$/g, '')
+}
+
+function splitNormalizedLines(text) {
+  return normalizeNewlines(text).split('\n')
+}
+
+function canonicalLine(text) {
+  return trimRightSpaces(text)
+}
+
+function trimTrailingEmptyLines(lines) {
+  const copy = [...lines]
+  while (copy.length > 0 && canonicalLine(copy[copy.length - 1]) === '') {
+    copy.pop()
+  }
+  return copy
+}
+
+function denormalizeNewlines(text, newline) {
+  if (newline === '\r\n') {
+    return text.replace(/\n/g, '\r\n')
+  }
+  return text
+}
+
+function detectNewline(text) {
+  return text.includes('\r\n') ? '\r\n' : '\n'
+}
+
+function getNearestContext(content, oldString) {
+  const lines = content.split(/\r?\n/)
+  const oldLines = normalizeNewlines(oldString).split('\n').filter(Boolean)
+  const firstToken = oldLines[0] || oldString.trim()
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (lines[index].includes(firstToken)) {
+      return lines.slice(index, index + 4).join('\n')
+    }
+  }
+
+  return lines.slice(0, 4).join('\n')
+}
+
+export function buildEditFailureMessage(content, oldString) {
+  return [
+    '未找到需要替换的文本。',
+    'oldString 必须与文件实际内容完全对应。',
+    '最接近的上下文：',
+    getNearestContext(content, oldString),
+  ].join('\n')
+}
+
+function tryLooseBlockReplace(normalizedContent, normalizedOld, normalizedNew) {
+  const contentLines = splitNormalizedLines(normalizedContent)
+  const oldLines = trimTrailingEmptyLines(splitNormalizedLines(normalizedOld))
+  const newLines = splitNormalizedLines(normalizedNew)
+
+  if (oldLines.length === 0) {
+    return null
+  }
+
+  for (let start = 0; start < contentLines.length; start += 1) {
+    let contentIndex = start
+    let oldIndex = 0
+
+    while (oldIndex < oldLines.length && contentIndex < contentLines.length) {
+      const expected = canonicalLine(oldLines[oldIndex])
+      const actual = canonicalLine(contentLines[contentIndex])
+
+      if (expected === actual) {
+        oldIndex += 1
+        contentIndex += 1
+        continue
+      }
+
+      if (actual === '') {
+        contentIndex += 1
+        continue
+      }
+
+      break
+    }
+
+    if (oldIndex === oldLines.length) {
+      const replaced = [
+        ...contentLines.slice(0, start),
+        ...newLines,
+        ...contentLines.slice(contentIndex),
+      ].join('\n')
+
+      return replaced
+    }
+  }
+
+  return null
+}
+
+export function applyLegacyEdit(content, oldString, newString, replaceAll = false) {
+  const newline = detectNewline(content)
+  const normalizedContent = normalizeNewlines(content)
+  const normalizedOld = normalizeNewlines(oldString)
+  const normalizedNew = normalizeNewlines(newString)
+
+  let nextNormalized = replaceAll
+    ? normalizedContent.split(normalizedOld).join(normalizedNew)
+    : normalizedContent.replace(normalizedOld, normalizedNew)
+
+  if (normalizedContent === nextNormalized && !replaceAll) {
+    const looseReplaced = tryLooseBlockReplace(normalizedContent, normalizedOld, normalizedNew)
+    if (looseReplaced !== null) {
+      nextNormalized = looseReplaced
+    }
+  }
+
+  if (normalizedContent === nextNormalized) {
+    return {
+      changed: false,
+      content,
+      error: buildEditFailureMessage(content, oldString),
+    }
+  }
+
+  return {
+    changed: true,
+    content: denormalizeNewlines(nextNormalized, newline),
+    error: null,
+  }
+}