chore: add more git commands

README.md

@@ -1,6 +1,6 @@
 # Synapse
 
-Operating system gateway for remote serverless environments. Synapse provides a WebSocket-based interface to interact with terminal sessions, manage files, and monitor system resources remotely.
+Operating system gateway for remote serverless environments. Synapse provides a WebSocket-based interface to interact with terminal sessions, manage files, monitor system resources, perform Git operations, and more.
 
 ## Features
 
@@ -137,17 +137,17 @@ await git.push();
 
 ```typescript
 // Lint and format code
-import { Synapse, CodeStyle } from "@appwrite.io/synapse";
+import { Synapse, Code } from "@appwrite.io/synapse";
 
 const synapse = new Synapse();
-const codeStyle = new CodeStyle(synapse);
+const code = new Code(synapse);
 
 // Format code with specific options
 const code = `function hello(name) {
 return "Hello, " + name;
 }`;
 
-const formatResult = await codeStyle.format(code, {
+const formatResult = await code.format(code, {
   language: "javascript",
   indent: 2,
   singleQuote: true,
@@ -157,7 +157,7 @@ const formatResult = await codeStyle.format(code, {
 console.log("Formatted code:", formatResult.data);
 
 // Lint code for potential issues
-const lintResult = await codeStyle.lint(code, {
+const lintResult = await code.lint(code, {
   language: "javascript",
   rules: {
     semi: "error",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appwrite.io/synapse",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Operating system gateway for remote serverless environments",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,23 +22,25 @@
   },
   "license": "MIT",
   "dependencies": {
+    "eslint": "^9.24.0",
     "node-pty": "^1.0.0",
-    "ws": "^8.18.1",
-    "eslint": "^9.23.0",
-    "prettier": "^3.5.3"
+    "prettier": "^3.5.3",
+    "ws": "^8.18.1"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.13",
-    "@types/ws": "^8.18.0",
-    "@typescript-eslint/eslint-plugin": "^8.28.0",
-    "@typescript-eslint/parser": "^8.28.0",
+    "@types/node": "^22.14.1",
+    "@types/node-fetch": "^2.6.12",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.29.1",
+    "@typescript-eslint/parser": "^8.29.1",
     "esbuild": "^0.25.2",
     "esbuild-plugin-file-path-extensions": "^2.1.4",
     "jest": "^29.7.0",
-    "ts-jest": "^29.3.0",
+    "node-fetch": "^3.3.2",
+    "ts-jest": "^29.3.2",
     "tsup": "^8.4.0",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.3"
   },
   "bugs": {
     "url": "https://github.com/appwrite/synapse/issues"

src/index.ts

@@ -1,4 +1,4 @@
-export { CodeStyle } from "./services/codestyle";
+export { Code } from "./services/code";
 export { Filesystem } from "./services/filesystem";
 export { Git } from "./services/git";
 export { System } from "./services/system";

src/services/code.ts

@@ -0,0 +1,189 @@
+import { ESLint } from "eslint";
+import { format, Options } from "prettier";
+import { Synapse } from "../synapse";
+
+export interface FormatOptions {
+  language: string;
+  indent?: number;
+  useTabs?: boolean;
+  semi?: boolean;
+  singleQuote?: boolean;
+  printWidth?: number;
+}
+
+export interface LintOptions {
+  language: string;
+  rules?: Record<string, "error" | "warn" | "off">;
+}
+
+export interface FormatResult {
+  success: boolean;
+  data?: string;
+  error?: string;
+}
+
+export interface LintResult {
+  success: boolean;
+  data?: {
+    issues: Array<{
+      line: number;
+      column: number;
+      severity: "error" | "warning";
+      rule: string;
+      message: string;
+    }>;
+  };
+  error?: string;
+}
+
+export class Code {
+  private synapse: Synapse;
+
+  /**
+   * Creates a new CodeStyle instance
+   * @param synapse The Synapse instance for WebSocket communication
+   */
+  constructor(synapse: Synapse) {
+    this.synapse = synapse;
+  }
+
+  private log(message: string): void {
+    const timestamp = new Date().toISOString();
+    console.log(`[Code][${timestamp}] ${message}`);
+  }
+
+  private getParserForLanguage(language: string): string {
+    const languageMap: Record<string, string> = {
+      javascript: "babel",
+      typescript: "typescript",
+      json: "json",
+      html: "html",
+      css: "css",
+      markdown: "markdown",
+      yaml: "yaml",
+    };
+
+    return languageMap[language.toLowerCase()] || "babel";
+  }
+
+  private toPrettierOptions(
+    language: string,
+    options?: FormatOptions,
+  ): Options {
+    const parser = this.getParserForLanguage(language);
+
+    return {
+      parser,
+      tabWidth: options?.indent || 2,
+      useTabs: options?.useTabs || false,
+      semi: options?.semi !== undefined ? options.semi : true,
+      singleQuote: options?.singleQuote || false,
+      printWidth: options?.printWidth || 80,
+    };
+  }
+
+  /**
+   * Format code according to specified options
+   * @param code The code to format
+   * @param options Formatting options
+   * @returns A promise resolving to the formatting result
+   */
+  async format(code: string, options: FormatOptions): Promise<FormatResult> {
+    try {
+      if (!code || typeof code !== "string") {
+        return {
+          success: false,
+          error: "Invalid code input: code must be a non-empty string",
+        };
+      }
+
+      if (!options.language) {
+        return {
+          success: false,
+          error: "Language must be specified in format options",
+        };
+      }
+
+      this.log(`Formatting code with language: ${options.language}`);
+
+      const prettierOptions = this.toPrettierOptions(options.language, options);
+      const formattedCode = await format(code, prettierOptions);
+
+      return {
+        success: true,
+        data: formattedCode,
+      };
+    } catch (error) {
+      this.log(
+        `Formatting failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      );
+      return {
+        success: false,
+        error: `Formatting failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      };
+    }
+  }
+
+  /**
+   * Lint code to identify issues
+   * @param code The code to lint
+   * @param options Linting options
+   * @returns A promise resolving to the linting result
+   */
+  async lint(code: string, options: LintOptions): Promise<LintResult> {
+    try {
+      if (!code || typeof code !== "string") {
+        return {
+          success: false,
+          error: "Invalid code input: code must be a non-empty string",
+        };
+      }
+
+      if (!options.language) {
+        return {
+          success: false,
+          error: "Language must be specified in lint options",
+        };
+      }
+
+      this.log(`Linting code with language: ${options.language}`);
+
+      const eslintOptions = {
+        overrideConfig: {
+          languageOptions: {
+            ecmaVersion: 2020,
+            sourceType: "module",
+          },
+          rules: options.rules || {},
+        },
+        overrideConfigFile: true,
+      } as ESLint.Options;
+
+      const linter = new ESLint(eslintOptions);
+      const eslintResult = await linter.lintText(code);
+
+      return {
+        success: true,
+        data: {
+          issues: eslintResult.flatMap((result) =>
+            result.messages.map((message) => ({
+              line: message.line,
+              column: message.column,
+              severity: message.severity === 2 ? "error" : "warning",
+              rule: message.ruleId || "",
+              message: message.message,
+            })),
+          ),
+        },
+      };
+    } catch (error) {
+      this.log(
+        `Linting failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      );
+      return {
+        success: false,
+        error: `Linting failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+      };
+    }
+  }
+}