encoding-aware-fs 0.1.2 → 0.1.4

package/dist/index.js

@@ -25813,6 +25813,36 @@ var init_read_file = __esm({
   }
 });
 
+// src/encoding/line-endings.ts
+function detectLineEnding(buffer) {
+  let crlf = 0;
+  let lf = 0;
+  for (let i = 0; i < buffer.length; i++) {
+    if (buffer[i] === 13 && i + 1 < buffer.length && buffer[i + 1] === 10) {
+      crlf++;
+      i++;
+    } else if (buffer[i] === 10) {
+      lf++;
+    }
+  }
+  if (crlf === 0 && lf === 0) {
+    return process.platform === "win32" ? "CRLF" : "LF";
+  }
+  return crlf >= lf ? "CRLF" : "LF";
+}
+function restoreLineEndings(text, style) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  if (style === "CRLF") {
+    return normalized.replace(/\n/g, "\r\n");
+  }
+  return normalized;
+}
+var init_line_endings = __esm({
+  "src/encoding/line-endings.ts"() {
+    "use strict";
+  }
+});
+
 // src/tools/write-file.ts
 function registerWriteFile(server2, config3, allowedDirectories) {
   server2.registerTool(
@@ -25829,8 +25859,10 @@ function registerWriteFile(server2, config3, allowedDirectories) {
     async (args) => {
       const validPath = await validatePath(args.path, allowedDirectories);
       let targetEncoding = config3.sourceEncoding || "GB18030";
+      let lineEndingStyle = process.platform === "win32" ? "CRLF" : "LF";
       try {
-        await fs5.access(validPath);
+        const existingBuffer = await fs5.readFile(validPath);
+        lineEndingStyle = detectLineEnding(existingBuffer);
         const detection = await detectEncoding(validPath);
         if (detection.encoding && isUtf8Encoding(detection.encoding)) {
           targetEncoding = "UTF-8";
@@ -25839,7 +25871,8 @@ function registerWriteFile(server2, config3, allowedDirectories) {
         }
       } catch {
       }
-      const encoded = encodeFromUtf8(args.content, targetEncoding);
+      const finalContent = restoreLineEndings(args.content, lineEndingStyle);
+      const encoded = encodeFromUtf8(finalContent, targetEncoding);
       try {
         await fs5.writeFile(validPath, encoded, { flag: "wx" });
       } catch (error2) {
@@ -25875,6 +25908,7 @@ var init_write_file = __esm({
     init_path_validation();
     init_detector();
     init_converter();
+    init_line_endings();
   }
 });
 
@@ -26400,6 +26434,7 @@ function registerEditFile(server2, config3, allowedDirectories) {
     async (args) => {
       const validPath = await validatePath(args.path, allowedDirectories);
       const buffer = await fs6.readFile(validPath);
+      const originalLineEnding = detectLineEnding(buffer);
       const detection = await detectEncoding(validPath);
       let originalEncoding = "UTF-8";
       if (detection.encoding && detection.confidence >= config3.confidenceThreshold && isGBEncoding(detection.encoding)) {
@@ -26411,7 +26446,8 @@ function registerEditFile(server2, config3, allowedDirectories) {
       const modifiedContent = applyEditsToContent(utf8Content, args.edits);
       const diff = createUnifiedDiff(utf8Content, modifiedContent, args.path);
       if (!args.dryRun) {
-        const encoded = isGBEncoding(originalEncoding) ? encodeFromUtf8(modifiedContent, originalEncoding) : Buffer.from(modifiedContent, "utf-8");
+        const finalContent = restoreLineEndings(modifiedContent, originalLineEnding);
+        const encoded = isGBEncoding(originalEncoding) ? encodeFromUtf8(finalContent, originalEncoding) : Buffer.from(finalContent, "utf-8");
         const tempPath = `${validPath}.${(0, import_crypto2.randomBytes)(16).toString("hex")}.tmp`;
         try {
           await fs6.writeFile(tempPath, encoded);
@@ -26441,6 +26477,7 @@ var init_edit_file = __esm({
     init_path_validation();
     init_detector();
     init_converter();
+    init_line_endings();
   }
 });
 
@@ -26539,6 +26576,10 @@ var init_config_io = __esm({
 // src/uninstaller.ts
 var uninstaller_exports = {};
 __export(uninstaller_exports, {
+  detectInstalled: () => detectInstalled,
+  isOpenCodeJsoncEmpty: () => isOpenCodeJsoncEmpty,
+  removeOpenCodeConfig: () => removeOpenCodeConfig,
+  removeRuleFile: () => removeRuleFile,
   runUninstaller: () => runUninstaller
 });
 async function fileExists(filePath) {
@@ -26561,8 +26602,18 @@ async function removeDirIfEmpty(dirPath) {
 function isEmptyMcpJson(data) {
   return data && typeof data === "object" && data.mcpServers && typeof data.mcpServers === "object" && Object.keys(data.mcpServers).length === 0 && Object.keys(data).length === 1;
 }
-function isEmptyOpenCodeJsonc(data) {
-  return data && typeof data === "object" && data.mcp && typeof data.mcp === "object" && Object.keys(data.mcp).length === 0 && Object.keys(data).length === 1;
+function isOpenCodeJsoncEmpty(data) {
+  if (!data || typeof data !== "object")
+    return false;
+  const keys = Object.keys(data);
+  return keys.every((key) => {
+    const val = data[key];
+    if (Array.isArray(val))
+      return val.length === 0;
+    if (typeof val === "object" && val !== null)
+      return Object.keys(val).length === 0;
+    return false;
+  });
 }
 async function detectInstalled(cwd) {
   const found = [];
@@ -26570,24 +26621,31 @@ async function detectInstalled(cwd) {
   const mcpJson = await readJsonFile(mcpJsonPath);
   const claudeSkillPath = path5.join(cwd, ".claude", "skills", "encoding-aware-fs", "SKILL.md");
   const hasClaudeSkill = await fileExists(claudeSkillPath);
-  if (mcpJson?.mcpServers?.["encoding-aware-fs"] || hasClaudeSkill) {
+  const claudeRulePath = path5.join(cwd, ".claude", "rules", "encoding-aware-fs.md");
+  const hasClaudeRule = await fileExists(claudeRulePath);
+  if (mcpJson?.mcpServers?.["encoding-aware-fs"] || hasClaudeSkill || hasClaudeRule) {
     found.push({
       type: "claude-code",
       name: "Claude Code (.mcp.json)",
       configPath: mcpJsonPath,
-      skillPath: hasClaudeSkill ? claudeSkillPath : void 0
+      skillPath: hasClaudeSkill ? claudeSkillPath : void 0,
+      rulePath: hasClaudeRule ? claudeRulePath : void 0
     });
   }
   const openCodePath = path5.join(cwd, "opencode.jsonc");
   const openCode = await readJsonFile(openCodePath);
   const openCodeSkillPath = path5.join(cwd, ".agents", "skills", "encoding-aware-fs", "SKILL.md");
   const hasOpenCodeSkill = await fileExists(openCodeSkillPath);
-  if (openCode?.mcp?.["encoding-aware-fs"] || hasOpenCodeSkill) {
+  const openCodeRulePath = path5.join(cwd, ".agents", "rules", "encoding-aware-fs.md");
+  const hasOpenCodeRule = await fileExists(openCodeRulePath);
+  const hasOpenCodeInstructions = Array.isArray(openCode?.instructions) && openCode.instructions.includes(".agents/rules/encoding-aware-fs.md");
+  if (openCode?.mcp?.["encoding-aware-fs"] || hasOpenCodeSkill || hasOpenCodeRule || hasOpenCodeInstructions) {
     found.push({
       type: "opencode",
       name: "OpenCode (opencode.jsonc)",
       configPath: openCodePath,
-      skillPath: hasOpenCodeSkill ? openCodeSkillPath : void 0
+      skillPath: hasOpenCodeSkill ? openCodeSkillPath : void 0,
+      rulePath: hasOpenCodeRule ? openCodeRulePath : void 0
     });
   }
   return found;
@@ -26605,17 +26663,28 @@ async function removeClaudeCodeEntry(configPath) {
     console.log(`  \u2713 Removed encoding-aware-fs entry from ${configPath}`);
   }
 }
-async function removeOpenCodeEntry(configPath) {
+async function removeOpenCodeConfig(configPath) {
   const data = await readJsonFile(configPath);
-  if (!data?.mcp?.["encoding-aware-fs"])
+  if (!data)
     return;
-  delete data.mcp["encoding-aware-fs"];
-  if (isEmptyOpenCodeJsonc(data)) {
+  if (data.mcp?.["encoding-aware-fs"]) {
+    delete data.mcp["encoding-aware-fs"];
+    if (Object.keys(data.mcp).length === 0)
+      delete data.mcp;
+  }
+  if (Array.isArray(data.instructions)) {
+    data.instructions = data.instructions.filter(
+      (i) => i !== ".agents/rules/encoding-aware-fs.md"
+    );
+    if (data.instructions.length === 0)
+      delete data.instructions;
+  }
+  if (isOpenCodeJsoncEmpty(data) || Object.keys(data).length === 0) {
     await fs9.unlink(configPath);
     console.log(`  \u2713 Removed ${configPath} (was empty after cleanup)`);
   } else {
     await writeJsonFile(configPath, data);
-    console.log(`  \u2713 Removed encoding-aware-fs entry from ${configPath}`);
+    console.log(`  \u2713 Removed encoding-aware-fs entries from ${configPath}`);
   }
 }
 async function removeSkillFiles(platform) {
@@ -26636,6 +26705,22 @@ async function removeSkillFiles(platform) {
   const parentDir = path5.dirname(skillsDir);
   await removeDirIfEmpty(parentDir);
 }
+async function removeRuleFile(platform) {
+  if (!platform.rulePath)
+    return;
+  try {
+    await fs9.unlink(platform.rulePath);
+    console.log(`  \u2713 Removed ${platform.rulePath}`);
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+    return;
+  }
+  const ruleDir = path5.dirname(platform.rulePath);
+  await removeDirIfEmpty(ruleDir);
+  const parentDir = path5.dirname(ruleDir);
+  await removeDirIfEmpty(parentDir);
+}
 async function runUninstaller() {
   const cwd = process.cwd();
   console.log();
@@ -26655,10 +26740,13 @@ async function runUninstaller() {
     if (p.skillPath) {
       console.log(`    + Skill file: ${p.skillPath}`);
     }
+    if (p.rulePath) {
+      console.log(`    + Rule file: ${p.rulePath}`);
+    }
   }
   console.log();
   const proceed = await (0, import_prompts.confirm)({
-    message: "Remove encoding-aware-fs MCP config entries and skill files?",
+    message: "Remove encoding-aware-fs MCP config entries, skill files, and rule files?",
     default: false
   });
   if (!proceed) {
@@ -26670,12 +26758,15 @@ async function runUninstaller() {
     if (p.type === "claude-code") {
       await removeClaudeCodeEntry(p.configPath);
     } else if (p.type === "opencode") {
-      await removeOpenCodeEntry(p.configPath);
+      await removeOpenCodeConfig(p.configPath);
     }
   }
   for (const p of installed) {
     await removeSkillFiles(p);
   }
+  for (const p of installed) {
+    await removeRuleFile(p);
+  }
   const encodingConfigPath = path5.join(cwd, ".encoding-converter.json");
   try {
     await fs9.access(encodingConfigPath);
@@ -26700,6 +26791,8 @@ var init_uninstaller = __esm({
 // src/installer.ts
 var installer_exports = {};
 __export(installer_exports, {
+  addOpenCodeInstructions: () => addOpenCodeInstructions,
+  copyRuleFile: () => copyRuleFile,
   runInstaller: () => runInstaller
 });
 function checkNodeVersion() {
@@ -26765,6 +26858,33 @@ async function copySkillFile(cwd, platform) {
   await fs10.copyFile(sourcePath, targetPath);
   console.log(`  \u2713 Installed skill \u2192 ${targetPath}`);
 }
+async function copyRuleFile(cwd, platform) {
+  const sourcePath = path6.join(path6.resolve(__dirname, ".."), "skills", platform, "RULE.md");
+  try {
+    await fs10.access(sourcePath);
+  } catch {
+    console.log(`  \u26A0 Rule file template not found, skipping`);
+    return;
+  }
+  const ruleDir = platform === "claude-code" ? path6.join(cwd, ".claude", "rules") : path6.join(cwd, ".agents", "rules");
+  const rulePath = path6.join(ruleDir, "encoding-aware-fs.md");
+  await fs10.mkdir(ruleDir, { recursive: true });
+  await fs10.copyFile(sourcePath, rulePath);
+  console.log(`  \u2713 Installed rule \u2192 ${rulePath}`);
+}
+async function addOpenCodeInstructions(cwd) {
+  const configPath = path6.join(cwd, "opencode.jsonc");
+  const existing = await readJsonFile(configPath);
+  const merged = existing ?? {};
+  if (!merged.instructions) {
+    merged.instructions = [];
+  }
+  const rulePath = ".agents/rules/encoding-aware-fs.md";
+  if (!merged.instructions.includes(rulePath)) {
+    merged.instructions.push(rulePath);
+  }
+  await writeJsonFile(configPath, merged);
+}
 async function ensureEncodingConfig(cwd) {
   const configPath = path6.join(cwd, ".encoding-converter.json");
   try {
@@ -26828,6 +26948,15 @@ async function runInstaller() {
   for (const platform of platforms) {
     await copySkillFile(cwd, platform);
   }
+  console.log();
+  console.log("Rule files:");
+  for (const platform of platforms) {
+    await copyRuleFile(cwd, platform);
+  }
+  if (platforms.includes("opencode")) {
+    await addOpenCodeInstructions(cwd);
+    console.log("  \u2713 Added rule to opencode.jsonc instructions");
+  }
   await ensureEncodingConfig(cwd);
   console.log();
   console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
@@ -26840,7 +26969,7 @@ async function runInstaller() {
     console.log("\u2502  OpenCode:    restart opencode            \u2502");
   }
   console.log("\u2502                                          \u2502");
-  console.log("\u2502  Skill files installed for AI discovery.  \u2502");
+  console.log("\u2502  Rule + Skill files installed for AI.     \u2502");
   console.log("\u2502  The MCP server will start automatically  \u2502");
   console.log("\u2502  when your AI tool connects.             \u2502");
   console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");

package/dist/server.js

@@ -25050,6 +25050,33 @@ function registerReadFile(server2, config3, allowedDirectories) {
 // src/tools/write-file.ts
 var fs5 = __toESM(require("fs/promises"));
 var import_crypto = require("crypto");
+
+// src/encoding/line-endings.ts
+function detectLineEnding(buffer) {
+  let crlf = 0;
+  let lf = 0;
+  for (let i = 0; i < buffer.length; i++) {
+    if (buffer[i] === 13 && i + 1 < buffer.length && buffer[i + 1] === 10) {
+      crlf++;
+      i++;
+    } else if (buffer[i] === 10) {
+      lf++;
+    }
+  }
+  if (crlf === 0 && lf === 0) {
+    return process.platform === "win32" ? "CRLF" : "LF";
+  }
+  return crlf >= lf ? "CRLF" : "LF";
+}
+function restoreLineEndings(text, style) {
+  const normalized = text.replace(/\r\n/g, "\n");
+  if (style === "CRLF") {
+    return normalized.replace(/\n/g, "\r\n");
+  }
+  return normalized;
+}
+
+// src/tools/write-file.ts
 function registerWriteFile(server2, config3, allowedDirectories) {
   server2.registerTool(
     "write_file",
@@ -25065,8 +25092,10 @@ function registerWriteFile(server2, config3, allowedDirectories) {
     async (args) => {
       const validPath = await validatePath(args.path, allowedDirectories);
       let targetEncoding = config3.sourceEncoding || "GB18030";
+      let lineEndingStyle = process.platform === "win32" ? "CRLF" : "LF";
       try {
-        await fs5.access(validPath);
+        const existingBuffer = await fs5.readFile(validPath);
+        lineEndingStyle = detectLineEnding(existingBuffer);
         const detection = await detectEncoding(validPath);
         if (detection.encoding && isUtf8Encoding(detection.encoding)) {
           targetEncoding = "UTF-8";
@@ -25075,7 +25104,8 @@ function registerWriteFile(server2, config3, allowedDirectories) {
         }
       } catch {
       }
-      const encoded = encodeFromUtf8(args.content, targetEncoding);
+      const finalContent = restoreLineEndings(args.content, lineEndingStyle);
+      const encoded = encodeFromUtf8(finalContent, targetEncoding);
       try {
         await fs5.writeFile(validPath, encoded, { flag: "wx" });
       } catch (error2) {
@@ -25604,6 +25634,7 @@ function registerEditFile(server2, config3, allowedDirectories) {
     async (args) => {
       const validPath = await validatePath(args.path, allowedDirectories);
       const buffer = await fs6.readFile(validPath);
+      const originalLineEnding = detectLineEnding(buffer);
       const detection = await detectEncoding(validPath);
       let originalEncoding = "UTF-8";
       if (detection.encoding && detection.confidence >= config3.confidenceThreshold && isGBEncoding(detection.encoding)) {
@@ -25615,7 +25646,8 @@ function registerEditFile(server2, config3, allowedDirectories) {
       const modifiedContent = applyEditsToContent(utf8Content, args.edits);
       const diff = createUnifiedDiff(utf8Content, modifiedContent, args.path);
       if (!args.dryRun) {
-        const encoded = isGBEncoding(originalEncoding) ? encodeFromUtf8(modifiedContent, originalEncoding) : Buffer.from(modifiedContent, "utf-8");
+        const finalContent = restoreLineEndings(modifiedContent, originalLineEnding);
+        const encoded = isGBEncoding(originalEncoding) ? encodeFromUtf8(finalContent, originalEncoding) : Buffer.from(finalContent, "utf-8");
         const tempPath = `${validPath}.${(0, import_crypto2.randomBytes)(16).toString("hex")}.tmp`;
         try {
           await fs6.writeFile(tempPath, encoded);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "encoding-aware-fs",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Encoding-aware file operations MCP Server for AI tools working with GB18030 projects",
   "main": "dist/server.js",
   "bin": {

package/skills/claude-code/RULE.md

@@ -0,0 +1,3 @@
+MUST use encoding-aware-fs MCP tools (read_file, write_file, edit_file)
+for ALL file operations in this project. NEVER use the built-in Read, Write,
+or Edit tools for any file inside the project directory.

package/skills/opencode/RULE.md

@@ -0,0 +1,3 @@
+MUST use encoding-aware-fs MCP tools (read_file, write_file, edit_file)
+for ALL file operations in this project. NEVER use the built-in Read, Write,
+or Edit tools for any file inside the project directory.

package/.encoding-converter.json

@@ -1,5 +0,0 @@
-{
-  "sourceEncoding": "GB18030",
-  "targetEncoding": "UTF-8",
-  "confidenceThreshold": 0.8
-}

package/.mcp.json

@@ -1,15 +0,0 @@
-{
-  "mcpServers": {
-    "encoding-aware-fs": {
-      "command": "cmd",
-      "args": [
-        "/c",
-        "npx",
-        "-y",
-        "encoding-aware-fs",
-        "serve"
-      ],
-      "env": {}
-    }
-  }
-}

package/opencode.jsonc

@@ -1,15 +0,0 @@
-{
-  "mcp": {
-    "encoding-aware-fs": {
-      "type": "local",
-      "command": [
-        "npx",
-        "-y",
-        "encoding-aware-fs",
-        "serve"
-      ],
-      "enabled": true,
-      "timeout": 30000
-    }
-  }
-}