fix: implement native JSON operations and resolve TypeScript strict mode issues

- Replace all fs-extra JSON methods (readJson/writeJson) with native JSON operations
- Fix fs-extra-safe implementation to handle cross-device moves properly
- Update test mocks to use readFile/writeFile with JSON strings
- Resolve ensureDir test to match actual Node.js behavior with recursive:true
- Maintain 95%+ test coverage requirement
- All TypeScript strict mode violations resolved
- All ESLint violations resolved

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Agent Communication MCP Server

src/core/ComplianceTracker.ts

@@ -166,7 +166,8 @@ export class ComplianceTracker {
 
     try {
       if (await fs.pathExists(recordPath)) {
-        const record = await fs.readJson(recordPath) as AgentComplianceRecord;
+        const content = await fs.readFile(recordPath, 'utf8');
+        const record = JSON.parse(content) as AgentComplianceRecord;
         // Convert string dates back to Date objects
         record.lastActivity = new Date(record.lastActivity);
         this.records.set(agent, record);
@@ -201,7 +202,8 @@ export class ComplianceTracker {
   private async saveAgentRecord(record: AgentComplianceRecord): Promise<void> {
     try {
       const recordPath = path.join(this.complianceDir, `${record.agent}.json`);
-      await fs.writeJson(recordPath, record);
+      const jsonStr = JSON.stringify(record, null, 2);
+      await fs.writeFile(recordPath, jsonStr);
     } catch (error) {
       // Error saving compliance record - silently continue
       void error; // Acknowledge but don't log

src/core/DelegationTracker.ts

@@ -289,7 +289,8 @@ export class DelegationTracker {
       for (const file of files) {
         if (file.endsWith('.json')) {
           const filePath = path.join(this.delegationsDir, file);
-          const record = await fs.readJson(filePath) as DelegationRecord;
+          const content = await fs.readFile(filePath, 'utf8');
+          const record = JSON.parse(content) as DelegationRecord;
 
           // Convert string date to Date object if needed
           const createdAt = new Date(record.createdAt);
@@ -322,7 +323,8 @@ export class DelegationTracker {
         if (file.endsWith('.json')) {
           try {
             const filePath = path.join(this.delegationsDir, file);
-            const record = await fs.readJson(filePath) as DelegationRecord;
+            const content = await fs.readFile(filePath, 'utf8');
+          const record = JSON.parse(content) as DelegationRecord;
 
             // Convert string dates to Date objects
             record.createdAt = new Date(record.createdAt);
@@ -359,7 +361,8 @@ export class DelegationTracker {
 
     try {
       if (await fs.pathExists(recordPath)) {
-        const record = await fs.readJson(recordPath) as DelegationRecord;
+        const content = await fs.readFile(recordPath, 'utf8');
+        const record = JSON.parse(content) as DelegationRecord;
         record.createdAt = new Date(record.createdAt);
         this.delegations.set(taskId, record);
         return record;
@@ -378,7 +381,8 @@ export class DelegationTracker {
   private async saveDelegationRecord(record: DelegationRecord): Promise<void> {
     try {
       const recordPath = path.join(this.delegationsDir, `${record.taskId}.json`);
-      await fs.writeJson(recordPath, record);
+      const jsonStr = JSON.stringify(record, null, 2);
+      await fs.writeFile(recordPath, jsonStr);
     } catch (error) {
       // Error saving delegation - silently continue
       void error; // Acknowledge but don't log

src/resources/ResourceManager.ts

@@ -387,7 +387,8 @@ export class ResourceManager {
   private async getServerVersion(): Promise<string> {
     try {
       const fs = await import('../utils/fs-extra-safe.js');
-      const packageJson = await fs.readJSON('./package.json') as { version?: string };
+      const content = await fs.readFile('./package.json', 'utf8');
+      const packageJson = JSON.parse(content) as { version?: string };
       return packageJson.version ?? '0.0.0';
     } catch {
       return '0.0.0';

src/resources/providers/ServerResourceProvider.ts

@@ -295,7 +295,8 @@ export class ServerResourceProvider implements ResourceProvider {
 
     try {
       const packageJsonPath = path.resolve(process.cwd(), 'package.json');
-      const packageJson = await fs.readJSON(packageJsonPath);
+      const content = await fs.readFile(packageJsonPath, 'utf8');
+      const packageJson = JSON.parse(content);
       const version = (packageJson as { version?: string }).version || '0.0.0';
 
       // Update cache

src/utils/fs-extra-safe.ts

@@ -349,7 +349,17 @@ class SafeFileSystem implements SafeFsInterface {
     }
 
     // Node.js built-in fallback - rename is atomic move operation
-    await nodeFs.rename(src, dest);
+    try {
+      await nodeFs.rename(src, dest);
+    } catch (error) {
+      // If cross-device link error, fallback to copy + remove
+      if ((error as NodeJS.ErrnoException).code === 'EXDEV') {
+        await nodeFs.copyFile(src, dest);
+        await nodeFs.unlink(src);
+      } else {
+        throw error;
+      }
+    }
   }
 
   async copy(src: string, dest: string, options?: Record<string, unknown>): Promise<void> {
@@ -481,17 +491,6 @@ export const ensureDir = (dirPath: string) => safeFs.ensureDir(dirPath);
 export const appendFile = (filePath: string, data: string) => safeFs.appendFile(filePath, data);
 export const move = (src: string, dest: string, options?: Record<string, unknown>) => safeFs.move(src, dest, options);
 export const copy = (src: string, dest: string, options?: Record<string, unknown>) => safeFs.copy(src, dest, options);
-// JSON utility functions - always use Node.js built-in JSON methods
-export const readJSON = async (filePath: string): Promise<unknown> => {
-  const content = await readFile(filePath, 'utf8');
-  return JSON.parse(content);
-};
-export const readJson = readJSON; // Alias
-export const writeJSON = async (filePath: string, data: unknown): Promise<void> => {
-  const jsonStr = JSON.stringify(data, null, 2);
-  await writeFile(filePath, jsonStr);
-};
-export const writeJson = writeJSON; // Alias
 export const mkdtemp = (prefix: string) => safeFs.mkdtemp(prefix);
 export const mkdir = (dirPath: string, options?: Mode | MakeDirectoryOptions | null) => safeFs.mkdir(dirPath, options);
 export const chmod = (filePath: string, mode: string | number) => safeFs.chmod(filePath, mode);

tests/integration/file-system-regression.test.ts

@@ -326,16 +326,16 @@ describe('File System Operations Regression Test', () => {
     });
 
     describe('JSON file operations', () => {
-      it('REGRESSION: should use fs.readJson and fs.writeJson correctly', async () => {
+      it('REGRESSION: should use fs.readFile and fs.writeFile with JSON.parse/stringify correctly', async () => {
         const jsonFile = path.join(testDir, 'test.json');
         const testData = { name: 'test', version: '1.0.0', items: [1, 2, 3] };
 
-        // This would fail with "fs.writeJson is not a function" if import is wrong
-        // Note: fs-extra-safe writeJson doesn't support options parameter
-        await fs.writeJson(jsonFile, testData);
+        // This would fail with "fs.writeFile is not a function" if import is wrong
+        await fs.writeFile(jsonFile, JSON.stringify(testData, null, 2));
 
-        // This would fail with "fs.readJson is not a function" if import is wrong
-        const readData = await fs.readJson(jsonFile);
+        // This would fail with "fs.readFile is not a function" if import is wrong
+        const readContent = await fs.readFile(jsonFile, 'utf8');
+        const readData = JSON.parse(readContent) as typeof testData;
         expect(readData).toEqual(testData);
       });
     });
@@ -367,8 +367,8 @@ describe('File System Operations Regression Test', () => {
       expect(typeof fs.pathExists).toBe('function');
       expect(typeof fs.stat).toBe('function');
       expect(typeof fs.remove).toBe('function');
-      expect(typeof fs.readJson).toBe('function');
-      expect(typeof fs.writeJson).toBe('function');
+      expect(typeof fs.readFile).toBe('function');
+      expect(typeof fs.writeFile).toBe('function');
       expect(typeof fs.copy).toBe('function');
 
       // All fs-extra operations are available and properly imported

tests/smoke/basic-functionality.smoke.ts

@@ -101,9 +101,10 @@ describe('Smoke Tests - Basic Functionality', () => {
       const jsonFile = path.join(tempDir, 'test.json');
       const data = { test: true, value: 123 };
 
-      // This will catch fs.readJsonSync vs fs.readJson issues
-      await fs.writeJson(jsonFile, data);
-      const readData = await fs.readJson(jsonFile);
+      // This will catch fs.readFile vs fs.writeFile issues with JSON
+      await fs.writeFile(jsonFile, JSON.stringify(data, null, 2));
+      const readContent = await fs.readFile(jsonFile, 'utf-8');
+      const readData = JSON.parse(readContent) as typeof data;
 
       expect(readData).toEqual(data);
     });

tests/unit/core/ComplianceTracker.test.ts

@@ -19,8 +19,8 @@ import * as path from 'path';
 jest.mock('../../../src/utils/fs-extra-safe.js', () => ({
   pathExists: jest.fn(),
   ensureDir: jest.fn(),
-  readJson: jest.fn(),
-  writeJson: jest.fn(),
+  readFile: jest.fn(),
+  writeFile: jest.fn(),
   remove: jest.fn(),
   readdir: jest.fn()
 }));
@@ -47,8 +47,8 @@ describe('ComplianceTracker', () => {
     // Default mock implementations
     mockFs.pathExists.mockResolvedValue(false);
     mockFs.ensureDir.mockResolvedValue(undefined);
-    mockFs.readJson.mockResolvedValue({});
-    mockFs.writeJson.mockResolvedValue(undefined);
+    mockFs.readFile.mockResolvedValue('{}');
+    mockFs.writeFile.mockResolvedValue(undefined);
 
     // Create ComplianceTracker instance
     complianceTracker = new ComplianceTracker(mockConfig);
@@ -145,12 +145,9 @@ describe('ComplianceTracker', () => {
       await complianceTracker.recordActivity('test-agent', activity);
 
       // Assert
-      expect(mockFs.writeJson).toHaveBeenCalledWith(
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
         path.join(mockConfig.commDir, '.compliance', 'test-agent.json'),
-        expect.objectContaining({
-          agent: 'test-agent',
-          tasksCreated: 1
-        })
+        expect.stringContaining('"agent": "test-agent"')
       );
     });
   });
@@ -171,7 +168,7 @@ describe('ComplianceTracker', () => {
         escalationLevel: 1
       };
 
-      mockFs.readJson.mockResolvedValue(perfectRecord);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(perfectRecord));
 
       // Act
       const level = await complianceTracker.getComplianceLevel('perfect-agent');
@@ -196,7 +193,7 @@ describe('ComplianceTracker', () => {
       };
 
       mockFs.pathExists.mockResolvedValue(true);
-      mockFs.readJson.mockResolvedValue(record);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(record));
 
       // Act
       const level = await complianceTracker.getComplianceLevel('poor-delegator');
@@ -222,7 +219,7 @@ describe('ComplianceTracker', () => {
       };
 
       mockFs.pathExists.mockResolvedValue(true);
-      mockFs.readJson.mockResolvedValue(record);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(record));
 
       // Act
       const level = await complianceTracker.getComplianceLevel('no-todo-agent');
@@ -248,7 +245,7 @@ describe('ComplianceTracker', () => {
       };
 
       mockFs.pathExists.mockResolvedValue(true);
-      mockFs.readJson.mockResolvedValue(record);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(record));
 
       // Act
       const level = await complianceTracker.getComplianceLevel('no-plan-agent');
@@ -284,7 +281,7 @@ describe('ComplianceTracker', () => {
         escalationLevel: 4
       };
 
-      mockFs.readJson.mockResolvedValue(record);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(record));
 
       // Act
       const level = await complianceTracker.getComplianceLevel('terrible-agent');
@@ -458,18 +455,15 @@ describe('ComplianceTracker', () => {
         escalationLevel: 1
       };
 
-      mockFs.readJson.mockResolvedValue(record);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(record));
 
       // Act
       await complianceTracker.updateComplianceScore('test-agent');
 
       // Assert
-      expect(mockFs.writeJson).toHaveBeenCalledWith(
+      expect(mockFs.writeFile).toHaveBeenCalledWith(
         expect.any(String),
-        expect.objectContaining({
-          complianceScore: expect.any(Number),
-          escalationLevel: expect.any(Number)
-        })
+        expect.stringContaining('"complianceScore": ')
       );
     });
   });
@@ -494,7 +488,7 @@ describe('ComplianceTracker', () => {
       };
 
       mockFs.readdir.mockResolvedValue(['stale-agent.json'] as unknown as string[]);
-      mockFs.readJson.mockResolvedValue(staleRecord);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(staleRecord));
       mockFs.pathExists.mockResolvedValue(true);
       mockFs.remove.mockResolvedValue(undefined);
 
@@ -522,7 +516,7 @@ describe('ComplianceTracker', () => {
         escalationLevel: 1
       };
 
-      mockFs.readJson.mockResolvedValue(recentRecord);
+      mockFs.readFile.mockResolvedValue(JSON.stringify(recentRecord));
       mockFs.pathExists.mockResolvedValue(true);
 
       // Act
@@ -536,7 +530,7 @@ describe('ComplianceTracker', () => {
   describe('error handling', () => {
     it('should handle file read errors gracefully', async () => {
       // Arrange
-      mockFs.readJson.mockRejectedValue(new Error('File read error'));
+      mockFs.readFile.mockRejectedValue(new Error('File read error'));
 
       // Act
       const level = await complianceTracker.getComplianceLevel('error-agent');
@@ -547,7 +541,7 @@ describe('ComplianceTracker', () => {
 
     it('should handle file write errors gracefully', async () => {
       // Arrange
-      mockFs.writeJson.mockRejectedValue(new Error('File write error'));
+      mockFs.writeFile.mockRejectedValue(new Error('File write error'));
 
       const activity: ComplianceActivity = {
         type: 'task_created',