@movemama/opencode-legacy 0.1.0

package/tools/txt-gb2312-tool.mjs

@@ -0,0 +1,392 @@
+import { existsSync } from 'node:fs';
+import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+import { getKnownIconvCandidates } from './opencode-paths.mjs';
+
+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;
+}
+
+const ICONV_CANDIDATES = [
+  'iconv',
+  process.env.OPENCODE_ICONV_PATH,
+  process.env.ICONV_PATH,
+  ...getKnownIconvCandidates(),
+  ...getDerivedIconvCandidates(),
+].filter(Boolean);
+
+const DEFAULT_ICONV_INSTALL_COMMAND = [
+  'winget',
+  'install',
+  '--id',
+  'mlocati.GetText',
+  '--source',
+  'winget',
+  '--accept-package-agreements',
+  '--accept-source-agreements',
+  '--disable-interactivity',
+];
+
+function runInstallCommand(command, args) {
+  return spawnSync(command, args, {
+    encoding: 'utf8',
+    shell: process.platform === 'win32',
+    env: process.env,
+  });
+}
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}
+
+function getIconvCandidates() {
+  if (process.env.OPENCODE_ICONV_DISABLE_FALLBACKS === '1') {
+    return [process.env.OPENCODE_ICONV_PATH].filter(Boolean);
+  }
+  return ICONV_CANDIDATES;
+}
+
+function tryResolveIconvPath() {
+  const candidates = getIconvCandidates();
+  const diagnostics = [];
+
+  for (const candidate of candidates) {
+    const result = spawnSync(candidate, ['--version'], { encoding: 'utf8' });
+    diagnostics.push({
+      candidate,
+      status: result.status,
+      error: result.error?.message ?? null,
+      stdout: (result.stdout || '').slice(0, 120),
+      stderr: (result.stderr || '').slice(0, 120),
+    });
+    if (result.status === 0) {
+      return { resolvedPath: candidate, diagnostics };
+    }
+  }
+
+  return { resolvedPath: null, diagnostics };
+}
+
+function tryAutoInstallIconv() {
+  if (process.env.OPENCODE_ICONV_SKIP_AUTO_INSTALL === '1') {
+    return false;
+  }
+
+  if (process.env.OPENCODE_ICONV_INSTALLER_NODE_SCRIPT) {
+    const nodeCommand = process.env.OPENCODE_NODE_PATH || process.execPath || 'node';
+    const result = spawnSync(nodeCommand, [process.env.OPENCODE_ICONV_INSTALLER_NODE_SCRIPT], {
+      encoding: 'utf8',
+      env: process.env,
+    });
+    return result.status === 0;
+  }
+
+  const [command, ...args] = DEFAULT_ICONV_INSTALL_COMMAND;
+  const result = runInstallCommand(command, args);
+
+  return result.status === 0;
+}
+
+function resolveIconvPath() {
+  const firstAttempt = tryResolveIconvPath();
+  const resolvedPath = firstAttempt.resolvedPath;
+  if (resolvedPath) {
+    return resolvedPath;
+  }
+
+  const installed = tryAutoInstallIconv();
+  if (installed) {
+    const secondAttempt = tryResolveIconvPath();
+    const installedPath = secondAttempt.resolvedPath;
+    if (installedPath) {
+      return installedPath;
+    }
+    fail(
+      [
+        'iconv 自动安装后仍不可用',
+        `cwd=${process.cwd()}`,
+        `OPENCODE_ICONV_PATH=${process.env.OPENCODE_ICONV_PATH || '<empty>'}`,
+        `ICONV_PATH=${process.env.ICONV_PATH || '<empty>'}`,
+        `PATH_SAMPLE=${(process.env.Path || process.env.PATH || '').slice(0, 300)}`,
+        `diagnostics=${JSON.stringify(secondAttempt.diagnostics)}`,
+      ].join(' | '),
+    );
+  }
+
+  fail(
+    [
+      'iconv 不可用、未安装、路径不可访问、自动安装失败或执行失败',
+      `cwd=${process.cwd()}`,
+      `OPENCODE_ICONV_PATH=${process.env.OPENCODE_ICONV_PATH || '<empty>'}`,
+      `ICONV_PATH=${process.env.ICONV_PATH || '<empty>'}`,
+      `PATH_SAMPLE=${(process.env.Path || process.env.PATH || '').slice(0, 300)}`,
+      `diagnostics=${JSON.stringify(firstAttempt.diagnostics)}`,
+    ].join(' | '),
+  );
+}
+
+function runIconv(iconvPath, args, options = {}) {
+  const result = spawnSync(iconvPath, args, {
+    encoding: 'buffer',
+    ...options,
+  });
+
+  if (result.status !== 0) {
+    const errorText = result.stderr ? result.stderr.toString('utf8') : 'iconv 执行失败';
+    fail(errorText.trim() || 'iconv 执行失败');
+  }
+
+  return result;
+}
+
+function detectNonGb2312Chars(iconvPath, text, limit = 8) {
+  const issues = [];
+  let line = 1;
+  let column = 1;
+
+  for (const char of text) {
+    if (char === '\r') {
+      continue;
+    }
+
+    if (char === '\n') {
+      line += 1;
+      column = 1;
+      continue;
+    }
+
+    const probe = spawnSync(iconvPath, ['-f', 'UTF-8', '-t', 'GB2312'], {
+      input: Buffer.from(char, 'utf8'),
+      encoding: 'buffer',
+    });
+
+    if (probe.status !== 0) {
+      issues.push({
+        char,
+        codePoint: `U+${char.codePointAt(0).toString(16).toUpperCase()}`,
+        line,
+        column,
+      });
+      if (issues.length >= limit) {
+        break;
+      }
+    }
+
+    column += 1;
+  }
+
+  return issues;
+}
+
+const GB2312_SAFE_REPLACEMENTS = new Map([
+  ['🙂', '[表情]'],
+  ['😀', '[表情]'],
+  ['😂', '[表情]'],
+  ['“', '"'],
+  ['”', '"'],
+  ['‘', "'"],
+  ['’', "'"],
+  ['—', '-'],
+  ['–', '-'],
+  ['…', '...'],
+  [' ', ' '],
+]);
+
+export function suggestGb2312SafeText(text) {
+  let changed = false;
+  let preview = '';
+
+  for (const char of text) {
+    const replacement = GB2312_SAFE_REPLACEMENTS.get(char);
+    if (replacement !== undefined) {
+      preview += replacement;
+      changed = true;
+    } else {
+      preview += char;
+    }
+  }
+
+  return { changed, preview };
+}
+
+function detectLineEnding(text) {
+  if (text.includes('\r\n')) {
+    return '\r\n';
+  }
+  return '\n';
+}
+
+async function readCommand(filePath) {
+  const iconvPath = resolveIconvPath();
+  const result = runIconv(iconvPath, ['-f', 'GB2312', '-t', 'UTF-8', filePath]);
+  process.stdout.write(result.stdout.toString('utf8'));
+}
+
+async function writeCommand(targetPath, sourcePath) {
+  const iconvPath = resolveIconvPath();
+  const sourceText = await readFile(sourcePath, 'utf8');
+  const lineEnding = detectLineEnding(sourceText);
+  const targetDir = path.dirname(targetPath);
+
+  await mkdir(targetDir, { recursive: true });
+
+  const tempDir = await mkdtemp(path.join(tmpdir(), 'txt-gb2312-tool-'));
+  const utf8TempPath = path.join(tempDir, 'input-utf8.txt');
+  const gb2312TempPath = path.join(tempDir, 'output-gb2312.txt');
+
+  try {
+    await writeFile(utf8TempPath, sourceText, 'utf8');
+
+    const convert = spawnSync(iconvPath, ['-f', 'UTF-8', '-t', 'GB2312', utf8TempPath], {
+      encoding: 'buffer',
+    });
+
+    if (convert.status !== 0) {
+      const issues = detectNonGb2312Chars(iconvPath, sourceText);
+      const suggestion = suggestGb2312SafeText(sourceText);
+      const issueText = issues.length > 0
+        ? issues.map((item) => `字符 ${JSON.stringify(item.char)} (${item.codePoint}) 位于第 ${item.line} 行第 ${item.column} 列`).join('；')
+        : '未能自动定位具体字符';
+      fail(
+        [
+          '写入 GB2312 失败，内容中存在不可编码字符。',
+          issueText,
+          '建议：替换这些字符，或先写入 `.utf8` / `.md` 临时文件再整理为最终 `.txt`。',
+          suggestion.changed ? `安全替换建议预览：${suggestion.preview.slice(0, 200)}` : '当前未生成自动替换建议。',
+          `iconv 报错：${convert.stderr ? convert.stderr.toString('utf8').trim() : 'unknown error'}`,
+        ].join(' '),
+      );
+    }
+
+    await writeFile(gb2312TempPath, convert.stdout);
+
+    runIconv(iconvPath, ['-f', 'GB2312', '-t', 'UTF-8', gb2312TempPath]);
+
+    await rename(gb2312TempPath, targetPath);
+
+    process.stdout.write(
+      [
+        `- 文件路径：\`${targetPath}\``,
+        '- 源编码：`UTF-8`',
+        '- 目标编码：`GB2312`',
+        `- 换行风格：\`${lineEnding === '\r\n' ? '\\r\\n' : '\\n'}\``,
+        '- 转换工具：`iconv`',
+        `- 转换命令：\`${iconvPath} -f UTF-8 -t GB2312 ${utf8TempPath} > ${gb2312TempPath}\``,
+        `- 验证命令：\`${iconvPath} -f GB2312 -t UTF-8 ${gb2312TempPath} > NUL\``,
+        '- 验证结果：通过',
+        '- 结论：已按 GB2312 编码保存，验证通过',
+      ].join('\n') + '\n'
+    );
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+}
+
+async function verifyCommand(filePath) {
+  const iconvPath = resolveIconvPath();
+  const raw = await readFile(filePath);
+  const result = runIconv(iconvPath, ['-f', 'GB2312', '-t', 'UTF-8', filePath]);
+  const text = result.stdout.toString('utf8');
+  const lineEnding = raw.includes(0x0d) && raw.includes(0x0a) ? '\r\n' : '\n';
+
+  if (text.length === 0 && raw.length > 0) {
+    fail('GB2312 回读验证失败');
+  }
+
+  process.stdout.write(
+    [
+      `- 文件路径：\`${filePath}\``,
+      '- 源编码：`GB2312`',
+      '- 目标编码：`GB2312`',
+      `- 换行风格：\`${lineEnding === '\r\n' ? '\\r\\n' : '\\n'}\``,
+      '- 转换工具：`iconv`',
+      '- 转换命令：`不适用`',
+      `- 验证命令：\`${iconvPath} -f GB2312 -t UTF-8 ${filePath} > NUL\``,
+      '- 验证结果：通过',
+      '- 结论：已按 GB2312 编码保存，验证通过',
+    ].join('\n') + '\n'
+  );
+}
+
+async function main() {
+  const [command, arg1, arg2] = process.argv.slice(2);
+
+  if (!command) {
+    fail('用法：txt-gb2312-tool.mjs <read|write|verify> <path> [sourcePath]');
+  }
+
+  if (command === 'read') {
+    if (!arg1) {
+      fail('read 子命令缺少文件路径');
+    }
+    await readCommand(arg1);
+    return;
+  }
+
+  if (command === 'write') {
+    if (!arg1 || !arg2) {
+      fail('write 子命令缺少目标路径或源文件路径');
+    }
+    await writeCommand(arg1, arg2);
+    return;
+  }
+
+  if (command === 'verify') {
+    if (!arg1) {
+      fail('verify 子命令缺少文件路径');
+    }
+    if (!existsSync(arg1)) {
+      fail('待验证文件不存在');
+    }
+    await verifyCommand(arg1);
+    return;
+  }
+
+  fail(`未知子命令：${command}`);
+}
+
+export function __testOnly_getIconvCandidatesForPath(pathValue) {
+  const previousPath = process.env.Path;
+  const previousPATH = process.env.PATH;
+  process.env.Path = pathValue;
+  process.env.PATH = pathValue;
+
+  try {
+    return [
+      'iconv',
+      process.env.OPENCODE_ICONV_PATH,
+      process.env.ICONV_PATH,
+      'C:/Users/Administrator/AppData/Local/Programs/gettext-iconv/bin/iconv.exe',
+      'C:/Users/Administrator/AppData/Local/Atlassian/SourceTree/git_local/usr/bin/iconv.exe',
+      ...getDerivedIconvCandidates(),
+    ].filter(Boolean);
+  } finally {
+    process.env.Path = previousPath;
+    process.env.PATH = previousPATH;
+  }
+}
+
+const isDirectExecution = process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url;
+
+if (isDirectExecution) {
+  await main();
+}

package/tools/write.js

@@ -0,0 +1,53 @@
+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 { 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()
+}
+
+function resolvePath(filePath, worktree) {
+  return path.isAbsolute(filePath) ? filePath : path.join(worktree, filePath)
+}
+
+async function writeLegacyFile(targetPath, content, encoding) {
+  const buffer = encodeLegacyText(content, encoding)
+  await writeFile(targetPath, buffer)
+  return `已按 ${encoding} 编码写入 ${targetPath}`
+}
+
+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?.encoding) {
+      return writeLegacyFile(filePath, args.content, matched.encoding)
+    }
+
+    await writeFile(filePath, args.content, 'utf8')
+    return `已写入 ${filePath}`
+  },
+})

package/tools/write.ts

@@ -0,0 +1,67 @@
+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}`
+  },
+})