@movemama/opencode-legacy 0.1.0

package/tools/legacy-router.mjs

@@ -0,0 +1,149 @@
+import path from 'node:path';
+
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, '/');
+}
+
+function globToRegExp(glob) {
+  const normalized = normalizePath(glob);
+  let pattern = '^';
+
+  for (let i = 0; i < normalized.length; i += 1) {
+    const ch = normalized[i];
+
+    if (ch === '*') {
+      const next = normalized[i + 1];
+      if (next === '*') {
+        pattern += '.*';
+        i += 1;
+      } else {
+        pattern += '[^/]*';
+      }
+      continue;
+    }
+
+    if (ch === '?') {
+      pattern += '.';
+      continue;
+    }
+
+    if (ch === '{') {
+      const closeIndex = normalized.indexOf('}', i);
+      if (closeIndex > i) {
+        const group = normalized
+          .slice(i + 1, closeIndex)
+          .split(',')
+          .map((part) => part.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+          .join('|');
+        pattern += `(${group})`;
+        i = closeIndex;
+        continue;
+      }
+    }
+
+    if ('\\.[]{}()+-^$|'.includes(ch)) {
+      pattern += `\\${ch}`;
+      continue;
+    }
+
+    pattern += ch;
+  }
+
+  pattern += '$';
+  return new RegExp(pattern, 'i');
+}
+
+export function createDefaultLegacyRules() {
+  return [
+    { glob: '**/*.txt', encoding: 'gb2312', strict: true },
+    { glob: '**/*.{ini,cfg,dat}', encoding: 'gbk', strict: false },
+  ];
+}
+
+export function matchLegacyRule(filePath, rules = createDefaultLegacyRules()) {
+  const normalized = normalizePath(filePath);
+  const matched = [];
+
+  for (const rule of rules) {
+    if (globToRegExp(rule.glob).test(normalized)) {
+      matched.push(rule);
+    }
+  }
+
+  if (matched.length === 0) {
+    return null;
+  }
+
+  matched.sort((left, right) => {
+    const rightPriority = Number(right.priority || 0);
+    const leftPriority = Number(left.priority || 0);
+    if (rightPriority !== leftPriority) {
+      return rightPriority - leftPriority;
+    }
+    return right.glob.length - left.glob.length;
+  });
+
+  return matched[0];
+}
+
+export function shouldUseLegacyTools(filePath, rules = createDefaultLegacyRules()) {
+  return Boolean(matchLegacyRule(filePath, rules));
+}
+
+export function buildLegacyToolCall({ tool, args, rules = createDefaultLegacyRules() }) {
+  const filePath = args.filePath ?? args.targetPath ?? args.path;
+  if (!filePath) {
+    return null;
+  }
+
+  const matched = matchLegacyRule(filePath, rules);
+  if (!matched) {
+    return null;
+  }
+
+  if (tool === 'read') {
+    return {
+      tool: 'legacy_read',
+      args: {
+        filePath,
+        encoding: matched.encoding,
+        strict: matched.strict,
+      },
+    };
+  }
+
+  if (tool === 'write') {
+    return {
+      tool: 'legacy_write',
+      args: {
+        filePath,
+        content: args.content,
+        encoding: matched.encoding,
+        strict: matched.strict,
+      },
+    };
+  }
+
+  if (tool === 'edit' || tool === 'apply_patch') {
+    return {
+      tool: 'legacy_edit',
+      args: {
+        filePath,
+        oldString: args.oldString,
+        newString: args.newString,
+        replaceAll: Boolean(args.replaceAll),
+        encoding: matched.encoding,
+        strict: matched.strict,
+      },
+    };
+  }
+
+  return null;
+}
+
+export function resolveLegacyConfigPaths(projectRoot, globalConfigRoot) {
+  return {
+    projectConfigPath: path.join(projectRoot, '.opencode', 'legacy-rules.json'),
+    globalConfigPath: path.join(globalConfigRoot, 'legacy-rules.json'),
+  };
+}

package/tools/legacy-search-core.mjs

@@ -0,0 +1,84 @@
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+export function createLineMatcher(pattern, options = {}) {
+  const flags = options.caseSensitive ? 'g' : 'gi'
+
+  if (options.fixedStrings) {
+    const escaped = escapeRegex(pattern)
+    const source = options.wholeWord ? `\\b${escaped}\\b` : escaped
+    const regex = new RegExp(source, flags)
+    return (line) => regex.test(line)
+  }
+
+  const source = options.wholeWord ? `\\b(?:${pattern})\\b` : pattern
+  const regex = new RegExp(source, flags)
+  return (line) => regex.test(line)
+}
+
+export function searchContentLines(content, pattern, options = {}) {
+  const matcher = createLineMatcher(pattern, options)
+  const lines = content.split(/\r?\n/)
+  const matches = []
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (matcher(lines[index])) {
+      matches.push({
+        line: index + 1,
+        text: lines[index],
+      })
+    }
+  }
+
+  return matches
+}
+
+export function searchContentLinesChunked(content, pattern, options = {}) {
+  const chunkSize = options.chunkSize || 1024 * 256
+  if (content.length <= chunkSize) {
+    return searchContentLines(content, pattern, options)
+  }
+
+  const matcher = createLineMatcher(pattern, options)
+  const matches = []
+  let offset = 0
+  let lineNumber = 1
+  let carry = ''
+
+  while (offset < content.length) {
+    const nextChunk = content.slice(offset, offset + chunkSize)
+    offset += chunkSize
+
+    const merged = carry + nextChunk
+    const hasMore = offset < content.length
+    const lines = merged.split(/\r?\n/)
+
+    if (hasMore) {
+      carry = lines.pop() ?? ''
+    } else {
+      carry = ''
+    }
+
+    for (const line of lines) {
+      if (matcher(line)) {
+        matches.push({
+          line: lineNumber,
+          text: line,
+        })
+      }
+      lineNumber += 1
+    }
+  }
+
+  if (carry) {
+    if (createLineMatcher(pattern, options)(carry)) {
+      matches.push({
+        line: lineNumber,
+        text: carry,
+      })
+    }
+  }
+
+  return matches
+}

package/tools/legacy.js

@@ -0,0 +1,78 @@
+import { tool } from '@opencode-ai/plugin'
+import { readFileSync, existsSync } from 'node:fs'
+import { writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { applyLegacyEdit } from './legacy-edit-core.mjs'
+import { decodeLegacyBuffer, encodeLegacyText } from './legacy-codec.js'
+
+function readLegacyFile(filePath, encoding) {
+  const buffer = readFileSync(filePath)
+  return decodeLegacyBuffer(buffer, encoding)
+}
+
+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)
+
+    return readLegacyFile(filePath, args.encoding)
+  },
+})
+
+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 buffer = encodeLegacyText(args.content, args.encoding)
+    await writeFile(filePath, buffer)
+    return `已按 ${args.encoding} 编码写入 ${filePath}`
+  },
+})
+
+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 = readLegacyFile(filePath, args.encoding)
+    const result = applyLegacyEdit(content, args.oldString, args.newString, Boolean(args.replaceAll))
+
+    if (!result.changed) {
+      throw new Error(result.error)
+    }
+
+    const buffer = encodeLegacyText(result.content, args.encoding)
+    await writeFile(filePath, buffer)
+    return `已按 ${args.encoding} 编码编辑 ${filePath}`
+  },
+})

package/tools/legacy.ts

@@ -0,0 +1,230 @@
+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/opencode-paths.mjs

@@ -0,0 +1,41 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const TOOLS_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.join(TOOLS_DIR, '..');
+
+export function getUserHome() {
+  return process.env.USERPROFILE || process.env.HOME || path.join('C:', 'Users', 'Administrator');
+}
+
+export function getGlobalOpencodeRoot() {
+  return path.join(getUserHome(), '.config', 'opencode');
+}
+
+export function getGlobalLegacyRulesPath() {
+  return path.join(getGlobalOpencodeRoot(), 'legacy-rules.json');
+}
+
+export function getGlobalToolPath(fileName) {
+  return path.join(getGlobalOpencodeRoot(), 'tools', fileName);
+}
+
+export function getBundledPackageRoot() {
+  return PACKAGE_ROOT;
+}
+
+export function getBundledLegacyRulesPath() {
+  return path.join(PACKAGE_ROOT, 'legacy-rules.json');
+}
+
+export function getBundledToolPath(fileName) {
+  return path.join(TOOLS_DIR, fileName);
+}
+
+export function getKnownIconvCandidates() {
+  const home = getUserHome();
+  return [
+    path.join(home, 'AppData', 'Local', 'Programs', 'gettext-iconv', 'bin', 'iconv.exe'),
+    path.join(home, 'AppData', 'Local', 'Atlassian', 'SourceTree', 'git_local', 'usr', 'bin', 'iconv.exe'),
+  ];
+}