Refactor code structure for improved readability and maintainability

Author: shtse8

packages/setup-mode/README.md

@@ -0,0 +1,55 @@
+# @sylphx/setup_mode
+
+This tool automatically adds or updates the 'sylphx' custom mode definition in Roo's `custom_modes.json` configuration file using the latest instructions from the `sylphlab/Playbook` GitHub repository.
+
+## Purpose
+
+Ensures that the 'sylphx' mode in Roo utilizes the most up-to-date core instructions defined in the central Playbook repository.
+
+## Features
+
+- Fetches the latest `custom_instructions_core.md` from `sylphlab/Playbook` on GitHub.
+- Locates the Roo extension's global storage settings directory.
+  - **Note:** Currently uses a hardcoded Windows path (`%APPDATA%\Code\User\globalStorage\rooveterinaryinc.roo-cline\settings`). Needs improvement for cross-platform compatibility.
+- Reads the existing `custom_modes.json`, creating it if it doesn't exist.
+- Adds or updates the mode definition with `slug: 'sylphx'`.
+- Writes the changes back to `custom_modes.json`.
+- Logs progress and errors to the console.
+
+## Usage
+
+### Running via npx (after publishing)
+
+```bash
+npx @sylphx/setup_mode
+```
+
+### Local Development
+
+1.  **Clone the repository (or ensure you have this directory).**
+2.  **Install dependencies:**
+    ```bash
+    npm install
+    ```
+3.  **Build the TypeScript code:**
+    ```bash
+    npm run build
+    ```
+4.  **Run the compiled code directly:**
+    ```bash
+    node dist/index.js
+    ```
+    *or* **Run using ts-node (for development):**
+    ```bash
+    npm run dev
+    ```
+5.  **Run tests:**
+    ```bash
+    npm test
+    ```
+
+## TODO
+
+- Implement robust, cross-platform detection of the VS Code extension global storage path for `rooveterinaryinc.roo-cline`. Consider libraries like `env-paths` or OS-specific logic. Fallback to prompting the user if detection fails.
+- Add more comprehensive error handling and user feedback.
+- Consider adding command-line arguments (e.g., specifying a path, using a specific GitHub branch/token).

packages/setup-mode/biome.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["@sylphlab/biome-config"]
+}

packages/setup-mode/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@sylphx/setup-mode",
+  "version": "0.1.0",
+  "description": "Updates Roo's custom_modes.json with the latest sylphx mode definition from GitHub.",
+  "type": "module",
+  "bin": {
+    "@sylphx/setup_mode": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "scripts": {
+    "format": "pnpx biome format --write .",
+    "check": "pnpx biome check --write --unsafe .",
+    "lint": "pnpm run check",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "tsup",
+    "validate": "pnpm run check && pnpm run build && pnpm run test",
+    "start": "node ./dist/index.js"
+  },
+  "keywords": [
+    "roo",
+    "cline",
+    "sylphx",
+    "custom-mode",
+    "setup"
+  ],
+  "author": "Sylph AI (via Roo)",
+  "license": "MIT",
+  "dependencies": {
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^3.3.2" 
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.8.0",
+    "@sylphlab/biome-config": "workspace:*",
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.14.2",
+    "@types/node-fetch": "^2.6.11",
+    "tsup": "^8.1.0",
+    "vitest": "^1.6.0",
+    "@sylphlab/typescript-config": "workspace:*",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/setup-mode/src/index.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import type { MockedFunction } from 'vitest';
+// Removed type-only import for fs
+import fetch from 'node-fetch';
+import type { Response } from 'node-fetch'; // Separate type import
+import { Buffer } from 'node:buffer'; // Explicitly import Buffer
+
+// --- Mocking ---
+// Mock node-fetch
+// We need to mock the default export for ESM
+vi.mock('node-fetch', () => ({
+    __esModule: true, // This is important for ESM modules
+    default: vi.fn(),
+}));
+const mockedFetch = fetch as MockedFunction<typeof fetch>;
+
+
+// Mock fs-extra
+vi.mock('fs-extra', async () => {
+    // Define mocks entirely inside the factory, but without default implementations for readJson/pathExists
+    const mockEnsureDir = vi.fn();
+    const mockPathExists = vi.fn();
+    const mockReadJson = vi.fn();
+    const mockWriteJson = vi.fn();
+
+    return {
+        __esModule: true,
+        ensureDir: mockEnsureDir,
+        pathExists: mockPathExists,
+        readJson: mockReadJson,
+        writeJson: mockWriteJson,
+        // Mock default export if necessary
+        default: {
+            ensureDir: mockEnsureDir,
+            pathExists: mockPathExists,
+            readJson: mockReadJson,
+            writeJson: mockWriteJson,
+        },
+    };
+});
+
+// Import the mocked module directly. Vitest ensures this is the mocked version.
+import * as fs from 'fs-extra';
+
+// Import the functions to test
+import {
+    fetchLatestInstructions,
+    readCustomModes,
+    updateModesData,
+    writeCustomModes,
+} from './index.js'; // Updated import path
+
+// --- Test Suite ---
+describe('@sylphx/setup_mode core logic', () => {
+
+    // Define constants used in tests (or export from src/index.ts)
+    const SYLPHX_MODE_SLUG = 'sylphx';
+    const SYLPHX_MODE_NAME = '🪽 Sylphx';
+    const SYLPHX_MODE_GROUPS = ["read", "edit", "browser", "command", "mcp"];
+    const SYLPHX_MODE_SOURCE = 'global';
+
+    beforeEach(() => {
+        // Reset mocks before each test
+        vi.clearAllMocks();
+        vi.resetAllMocks(); // Resets all mocks including spies and call history
+        // Mock console methods to prevent test output clutter
+        vi.spyOn(console, 'log').mockImplementation(() => {});
+        vi.spyOn(console, 'warn').mockImplementation(() => {});
+        vi.spyOn(console, 'error').mockImplementation(() => {});
+    });
+
+     afterEach(() => {
+        // Restore console mocks
+        vi.restoreAllMocks();
+    });
+
+    // --- fetchLatestInstructions Tests ---
+    describe('fetchLatestInstructions', () => {
+        // No dynamic import needed here anymore
+
+        it('should fetch and decode instructions successfully', async () => {
+            const mockContent = 'Test Markdown Content';
+            const encodedContent = Buffer.from(mockContent).toString('base64');
+            mockedFetch.mockResolvedValueOnce({
+                ok: true,
+                // Return the expected structure directly
+                json: async () => ({ content: encodedContent, encoding: 'base64' }),
+            } as Response); // Use the imported Response type
+
+            const instructions = await fetchLatestInstructions();
+            expect(instructions).toBe(mockContent);
+            expect(mockedFetch).toHaveBeenCalledTimes(1);
+            // Add check for URL if needed: expect(mockedFetch).toHaveBeenCalledWith(EXPECTED_URL, expect.any(Object));
+        });
+
+        it('should throw error on fetch failure', async () => {
+             mockedFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                statusText: 'Not Found',
+            } as Response);
+
+            await expect(fetchLatestInstructions()).rejects.toThrow(/GitHub API request failed: 404 Not Found/);
+            expect(console.error).toHaveBeenCalledWith('Error fetching from GitHub:', expect.any(Error));
+        });
+
+         it('should throw error on API error message', async () => {
+             mockedFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ message: 'API rate limit exceeded' }),
+            } as Response);
+
+            await expect(fetchLatestInstructions()).rejects.toThrow(/GitHub API error: API rate limit exceeded/);
+             expect(console.error).toHaveBeenCalledWith('Error fetching from GitHub:', expect.any(Error));
+        });
+
+         it('should throw error on invalid content structure', async () => {
+             mockedFetch.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({ content: 'some content', encoding: 'utf-8' }), // Wrong encoding
+            } as Response);
+
+            await expect(fetchLatestInstructions()).rejects.toThrow(/Invalid content received from GitHub API/);
+             expect(console.error).toHaveBeenCalledWith('Error fetching from GitHub:', expect.any(Error));
+        });
+    });
+
+    // --- readCustomModes Tests ---
+    describe('readCustomModes', () => {
+        // No dynamic import needed here anymore
+
+        it('should read existing valid JSON', async () => {
+            const mockData = { customModes: [{ slug: 'test', name: 'Test', roleDefinition: '...', groups: [], source: 'user' }] };
+            // Explicitly set mocks for this test case
+            vi.mocked(fs.pathExists).mockImplementationOnce(async () => true); // Ensure pathExists is true
+            vi.mocked(fs.readJson).mockResolvedValueOnce(mockData); // Use Once for safety
+
+            const data = await readCustomModes();
+            expect(data).toEqual(mockData);
+            expect(fs.ensureDir).toHaveBeenCalledTimes(1);
+            expect(fs.readJson).toHaveBeenCalledTimes(1);
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Successfully read custom modes file.'));
+        });
+
+        it('should create file if it does not exist', async () => {
+            vi.mocked(fs.pathExists).mockImplementationOnce(async () => false); // Use mockImplementationOnce
+            const initialData = { customModes: [] };
+            // Ensure writeJson mock is reset/doesn't interfere if needed, though not strictly necessary here
+            vi.mocked(fs.writeJson).mockResolvedValueOnce(undefined);
+
+            const data = await readCustomModes();
+            expect(data).toEqual(initialData);
+            expect(fs.ensureDir).toHaveBeenCalledTimes(1);
+            expect(fs.writeJson).toHaveBeenCalledWith(expect.any(String), initialData, { spaces: 2 });
+            expect(fs.readJson).not.toHaveBeenCalled();
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('custom_modes.json not found. Creating a new one.'));
+        });
+
+         it('should return default and warn on invalid JSON', async () => {
+            vi.mocked(fs.pathExists).mockImplementationOnce(async () => true); // Use mockImplementationOnce
+            vi.mocked(fs.readJson).mockRejectedValueOnce(new SyntaxError('Invalid JSON')); // Use Once
+            const initialData = { customModes: [] };
+
+            const data = await readCustomModes();
+            expect(data).toEqual(initialData);
+            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Error parsing JSON'), expect.any(SyntaxError));
+            expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('File content might be corrupted. Attempting to reset.'));
+        });
+
+         it('should return default and warn on malformed structure', async () => {
+           vi.mocked(fs.pathExists).mockImplementationOnce(async () => true); // Use mockImplementationOnce
+            vi.mocked(fs.readJson).mockResolvedValueOnce({ someOtherProperty: [] }); // Use Once, Missing customModes array
+            const initialData = { customModes: [] };
+
+            const data = await readCustomModes();
+            expect(data).toEqual(initialData);
+             expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('custom_modes.json seems malformed. Resetting to default structure.'));
+        });
+
+         it('should throw error on other fs read errors', async () => {
+           vi.mocked(fs.pathExists).mockImplementationOnce(async () => true); // Use mockImplementationOnce
+            const readError = new Error('Permission denied');
+            vi.mocked(fs.readJson).mockRejectedValueOnce(readError); // Use Once
+
+            await expect(readCustomModes()).rejects.toThrow(/Failed to read or parse.*Permission denied/);
+            expect(console.error).toHaveBeenCalledWith('Error reading custom modes file:', readError);
+        });
+    });
+
+    // --- updateModesData Tests ---
+    describe('updateModesData', () => {
+        // No dynamic import needed here anymore
+
+         it('should add new mode if not exists', () => {
+            const initialData = { customModes: [] };
+            const instructions = 'New Instructions';
+            const updatedData = updateModesData(initialData, instructions);
+
+            expect(updatedData.customModes).toHaveLength(1);
+            // Assign to variable and check existence for type safety
+            const addedMode = updatedData.customModes[0];
+            expect(addedMode).toBeDefined();
+            if (addedMode) {
+                expect(addedMode.slug).toBe(SYLPHX_MODE_SLUG);
+                expect(addedMode.roleDefinition).toBe(instructions);
+                expect(addedMode.name).toBe(SYLPHX_MODE_NAME);
+                expect(addedMode.groups).toEqual(SYLPHX_MODE_GROUPS);
+                expect(addedMode.source).toBe(SYLPHX_MODE_SOURCE);
+            }
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining(`Adding new '${SYLPHX_MODE_SLUG}' mode definition.`));
+         });
+
+         it('should update existing mode', () => {
+            const initialData = { customModes: [{ slug: SYLPHX_MODE_SLUG, name: 'Old Name', roleDefinition: 'Old Def', groups: [], source: 'user' }] };
+            const instructions = 'Updated Instructions';
+            const updatedData = updateModesData(initialData, instructions);
+
+            expect(updatedData.customModes).toHaveLength(1);
+             // Assign to variable and check existence
+            const updatedMode = updatedData.customModes[0];
+            expect(updatedMode).toBeDefined();
+            if (updatedMode) {
+                expect(updatedMode.slug).toBe(SYLPHX_MODE_SLUG);
+                expect(updatedMode.roleDefinition).toBe(instructions);
+                expect(updatedMode.name).toBe(SYLPHX_MODE_NAME); // Name gets updated
+                expect(updatedMode.groups).toEqual(SYLPHX_MODE_GROUPS); // Groups updated
+                expect(updatedMode.source).toBe(SYLPHX_MODE_SOURCE); // Source updated
+            }
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining(`Updating existing '${SYLPHX_MODE_SLUG}' mode definition.`));
+         });
+    });
+
+    // --- writeCustomModes Tests ---
+     describe('writeCustomModes', () => {
+        // No dynamic import needed here anymore
+
+         it('should call fs.writeJson with correct data', async () => {
+            const dataToWrite = { customModes: [{ slug: SYLPHX_MODE_SLUG, name: SYLPHX_MODE_NAME, roleDefinition: 'Test Def', groups: SYLPHX_MODE_GROUPS, source: SYLPHX_MODE_SOURCE }] };
+            await writeCustomModes(dataToWrite);
+
+            expect(fs.writeJson).toHaveBeenCalledTimes(1);
+            expect(fs.writeJson).toHaveBeenCalledWith(expect.any(String), dataToWrite, { spaces: 2 });
+            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Successfully updated custom_modes.json.'));
+         });
+
+         it('should throw error on fs write error', async () => {
+             const writeError = new Error('Disk full');
+             vi.mocked(fs.writeJson).mockRejectedValueOnce(writeError); // Use Once
+            const dataToWrite = { customModes: [] };
+
+            await expect(writeCustomModes(dataToWrite)).rejects.toThrow(/Failed to write updates.*Disk full/);
+            expect(console.error).toHaveBeenCalledWith('Error writing custom modes file:', writeError);
+         });
+     });
+});