before converting to ts

Author: AnujaKalahara99

Frontend/src/App/CodeEditor/MonacoEditor/MonacoEditor.tsx

@@ -193,6 +193,97 @@ export default function MonacoEditor({
     return initialValue;
   };
 
+  // Add this to your MonacoEditor.tsx, updating your existing useEffect
+
+  useEffect(() => {
+    if (editorRef.current) {
+      // Configure TypeScript compiler options with more advanced settings
+      monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+        target: monaco.languages.typescript.ScriptTarget.Latest,
+        allowNonTsExtensions: true,
+        moduleResolution:
+          monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+        module: monaco.languages.typescript.ModuleKind.ESNext,
+        noEmit: true,
+        typeRoots: ["node_modules/@types"],
+        jsx: monaco.languages.typescript.JsxEmit.React,
+        allowJs: true,
+        checkJs: true, // Enable JavaScript validation
+        strict: true,
+        esModuleInterop: true,
+        allowSyntheticDefaultImports: true,
+        resolveJsonModule: true,
+        noImplicitAny: false, // More permissive for quick editing
+      });
+
+      // Set diagnostic options to show errors for imports
+      monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+        noSemanticValidation: false,
+        noSyntaxValidation: false,
+        noSuggestionDiagnostics: false,
+        diagnosticCodesToIgnore: [],
+      });
+
+      // Add basic browser and DOM typings
+      monaco.languages.typescript.javascriptDefaults.addExtraLib(
+        `
+      // Basic DOM and browser APIs
+      interface Window {
+        document: Document;
+        console: Console;
+        localStorage: Storage;
+        sessionStorage: Storage;
+        setTimeout(callback: Function, ms: number): number;
+        clearTimeout(id: number): void;
+        setInterval(callback: Function, ms: number): number;
+        clearInterval(id: number): void;
+      }
+      declare var window: Window;
+      declare var document: Document;
+      declare var console: Console;
+      
+      // Common modules
+      declare module "react" {
+        export const useState: any;
+        export const useEffect: any;
+        export const useRef: any;
+        export const useCallback: any;
+        export const useMemo: any;
+        export const useContext: any;
+        export default any;
+      }
+      declare module "react-dom" {
+        export const createRoot: any;
+        export default any;
+      }
+      `,
+        "ts:filename/lib.d.ts"
+      );
+
+      // Register a mock file system for handling imports
+      const fileMap = {
+        "/src/utils.js": `
+        export const add = (a, b) => a + b;
+        export const subtract = (a, b) => a - b;
+        export default { add, subtract };
+      `,
+        "/src/constants.js": `
+        export const PI = 3.14159;
+        export const MAX_VALUE = 1000;
+        export default { PI, MAX_VALUE };
+      `,
+      };
+
+      // Register each mock file
+      Object.entries(fileMap).forEach(([filePath, content]) => {
+        monaco.languages.typescript.javascriptDefaults.addExtraLib(
+          content,
+          `file:${filePath}`
+        );
+      });
+    }
+  }, [editorRef.current]);
+
   return (
     <div className="h-full flex flex-col">
       <CollaborativeCursor

Version_Engine/package-lock.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "@supabase/supabase-js": "^2.57.2"
+  }
+}

Version_Engine/package.json

@@ -1,6 +1,91 @@
-const handleCommit = async (sessionId) => {
+import fs from "fs/promises";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import {
+  getGitFolderFromStorage,
+  checkGitFolderExists,
+  saveGitFolderToStorage,
+  saveCommitToDatabase,
+  getLatestCommit,
+} from "../utils/database.js";
+
+const execPromise = promisify(exec);
+
+/**
+ * Handles a commit operation for a session
+ *
+ * @param {string} sessionId - The session ID
+ * @param {string} message - The commit message
+ * @param {string} branchId - The branch ID
+ * @returns {Promise<Object>} - Returns commit result
+ */
+const handleCommit = async (sessionId, message, branchId) => {
   console.log(`Handling commit for session: ${sessionId}`);
-  return "Commit job handled";
+
+  try {
+    const gitRepoPath = await getGitFolderFromStorage(sessionId);
+
+    const gitInitialized = await checkGitFolderExists(sessionId);
+    if (!gitInitialized) {
+      console.log(
+        `Git not initialized for session ${sessionId}, initializing now...`
+      );
+      await execPromise("git init", { cwd: gitRepoPath });
+      await execPromise(
+        'git config --local user.email "system@codespace.com"',
+        { cwd: gitRepoPath }
+      );
+      await execPromise('git config --local user.name "Codespace System"', {
+        cwd: gitRepoPath,
+      });
+    }
+
+    await execPromise("git add .", { cwd: gitRepoPath });
+
+    const commitMessage = message || "Automated commit";
+    const { stdout } = await execPromise(`git commit -m "${commitMessage}"`, {
+      cwd: gitRepoPath,
+    });
+
+    const commitHashMatch = stdout.match(/\[([^\]]+)\s([a-f0-9]{7,40})\]/);
+    if (!commitHashMatch) {
+      throw new Error("Could not extract commit hash from git output");
+    }
+    const commitHash = commitHashMatch[2];
+
+    const commitRecord = await saveCommitToDatabase(
+      branchId,
+      null,
+      commitHash,
+      commitMessage
+    );
+
+    await saveGitFolderToStorage(sessionId);
+
+    return {
+      success: true,
+      message: "Commit successful",
+      commitId: commitRecord.id,
+      commitHash: commitHash,
+    };
+  } catch (error) {
+    if (error.message && error.message.includes("nothing to commit")) {
+      console.log("No changes to commit");
+      return {
+        success: false,
+        message: "No changes to commit",
+        error: "no_changes",
+      };
+    }
+
+    console.error("Error in handleCommit:", error);
+    return {
+      success: false,
+      message: `Commit failed: ${error.message}`,
+      error: error.message,
+    };
+  }
 };
 
 export default handleCommit;

Version_Engine/worker-git/handlers/commit.js

@@ -24,7 +24,11 @@ new Worker(
         let msg = "Unknown job type";
         switch (job.data.type) {
           case "COMMIT":
-            msg = await handleCommit(job.data);
+            msg = await handleCommit(
+              job.data.sessionId,
+              job.data.message,
+              job.data.branchId
+            );
             break;
           case "ROLLBACK":
             msg = await handleRollback(job.data);