neural-loom 0.1.1

package/public/file.svg

@@ -0,0 +1 @@
+<svg fill="none" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path d="M14.5 13.5V5.41a1 1 0 0 0-.3-.7L9.8.29A1 1 0 0 0 9.08 0H1.5v13.5A2.5 2.5 0 0 0 4 16h8a2.5 2.5 0 0 0 2.5-2.5m-1.5 0v-7H8v-5H3v12a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1M9.5 5V2.12L12.38 5zM5.13 5h-.62v1.25h2.12V5zm-.62 3h7.12v1.25H4.5zm.62 3h-.62v1.25h7.12V11z" clip-rule="evenodd" fill="#666" fill-rule="evenodd"/></svg>

package/public/globe.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><g clip-path="url(#a)"><path fill-rule="evenodd" clip-rule="evenodd" d="M10.27 14.1a6.5 6.5 0 0 0 3.67-3.45q-1.24.21-2.7.34-.31 1.83-.97 3.1M8 16A8 8 0 1 0 8 0a8 8 0 0 0 0 16m.48-1.52a7 7 0 0 1-.96 0H7.5a4 4 0 0 1-.84-1.32q-.38-.89-.63-2.08a40 40 0 0 0 3.92 0q-.25 1.2-.63 2.08a4 4 0 0 1-.84 1.31zm2.94-4.76q1.66-.15 2.95-.43a7 7 0 0 0 0-2.58q-1.3-.27-2.95-.43a18 18 0 0 1 0 3.44m-1.27-3.54a17 17 0 0 1 0 3.64 39 39 0 0 1-4.3 0 17 17 0 0 1 0-3.64 39 39 0 0 1 4.3 0m1.1-1.17q1.45.13 2.69.34a6.5 6.5 0 0 0-3.67-3.44q.65 1.26.98 3.1M8.48 1.5l.01.02q.41.37.84 1.31.38.89.63 2.08a40 40 0 0 0-3.92 0q.25-1.2.63-2.08a4 4 0 0 1 .85-1.32 7 7 0 0 1 .96 0m-2.75.4a6.5 6.5 0 0 0-3.67 3.44 29 29 0 0 1 2.7-.34q.31-1.83.97-3.1M4.58 6.28q-1.66.16-2.95.43a7 7 0 0 0 0 2.58q1.3.27 2.95.43a18 18 0 0 1 0-3.44m.17 4.71q-1.45-.12-2.69-.34a6.5 6.5 0 0 0 3.67 3.44q-.65-1.27-.98-3.1" fill="#666"/></g><defs><clipPath id="a"><path fill="#fff" d="M0 0h16v16H0z"/></clipPath></defs></svg>

package/public/next.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 394 80"><path fill="#000" d="M262 0h68.5v12.7h-27.2v66.6h-13.6V12.7H262V0ZM149 0v12.7H94v20.4h44.3v12.6H94v21h55v12.6H80.5V0h68.7zm34.3 0h-17.8l63.8 79.4h17.9l-32-39.7 32-39.6h-17.9l-23 28.6-23-28.6zm18.3 56.7-9-11-27.1 33.7h17.8l18.3-22.7z"/><path fill="#000" d="M81 79.3 17 0H0v79.3h13.6V17l50.2 62.3H81Zm252.6-.4c-1 0-1.8-.4-2.5-1s-1.1-1.6-1.1-2.6.3-1.8 1-2.5 1.6-1 2.6-1 1.8.3 2.5 1a3.4 3.4 0 0 1 .6 4.3 3.7 3.7 0 0 1-3 1.8zm23.2-33.5h6v23.3c0 2.1-.4 4-1.3 5.5a9.1 9.1 0 0 1-3.8 3.5c-1.6.8-3.5 1.3-5.7 1.3-2 0-3.7-.4-5.3-1s-2.8-1.8-3.7-3.2c-.9-1.3-1.4-3-1.4-5h6c.1.8.3 1.6.7 2.2s1 1.2 1.6 1.5c.7.4 1.5.5 2.4.5 1 0 1.8-.2 2.4-.6a4 4 0 0 0 1.6-1.8c.3-.8.5-1.8.5-3V45.5zm30.9 9.1a4.4 4.4 0 0 0-2-3.3 7.5 7.5 0 0 0-4.3-1.1c-1.3 0-2.4.2-3.3.5-.9.4-1.6 1-2 1.6a3.5 3.5 0 0 0-.3 4c.3.5.7.9 1.3 1.2l1.8 1 2 .5 3.2.8c1.3.3 2.5.7 3.7 1.2a13 13 0 0 1 3.2 1.8 8.1 8.1 0 0 1 3 6.5c0 2-.5 3.7-1.5 5.1a10 10 0 0 1-4.4 3.5c-1.8.8-4.1 1.2-6.8 1.2-2.6 0-4.9-.4-6.8-1.2-2-.8-3.4-2-4.5-3.5a10 10 0 0 1-1.7-5.6h6a5 5 0 0 0 3.5 4.6c1 .4 2.2.6 3.4.6 1.3 0 2.5-.2 3.5-.6 1-.4 1.8-1 2.4-1.7a4 4 0 0 0 .8-2.4c0-.9-.2-1.6-.7-2.2a11 11 0 0 0-2.1-1.4l-3.2-1-3.8-1c-2.8-.7-5-1.7-6.6-3.2a7.2 7.2 0 0 1-2.4-5.7 8 8 0 0 1 1.7-5 10 10 0 0 1 4.3-3.5c2-.8 4-1.2 6.4-1.2 2.3 0 4.4.4 6.2 1.2 1.8.8 3.2 2 4.3 3.4 1 1.4 1.5 3 1.5 5h-5.8z"/></svg>

package/public/vercel.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1155 1000"><path d="m577.3 0 577.4 1000H0z" fill="#fff"/></svg>

package/public/window.svg

@@ -0,0 +1 @@
+<svg fill="none" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path fill-rule="evenodd" clip-rule="evenodd" d="M1.5 2.5h13v10a1 1 0 0 1-1 1h-11a1 1 0 0 1-1-1zM0 1h16v11.5a2.5 2.5 0 0 1-2.5 2.5h-11A2.5 2.5 0 0 1 0 12.5zm3.75 4.5a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5M7 4.75a.75.75 0 1 1-1.5 0 .75.75 0 0 1 1.5 0m1.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5" fill="#666"/></svg>

package/src/app/api/context/aider/route.ts

@@ -0,0 +1,113 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const configDir = path.join(process.cwd(), ".ai", "neural-loom");
+const configPath = path.join(configDir, "aider.json");
+
+function ensureDir() {
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+}
+
+function maskKey(key: string): string {
+  if (!key) return "";
+  if (key.length <= 8) return "********";
+  return `${key.slice(0, 6)}...${key.slice(-4)}`;
+}
+
+export async function GET() {
+  try {
+    if (fs.existsSync(configPath)) {
+      const rawData = fs.readFileSync(configPath, "utf8");
+      const config = JSON.parse(rawData);
+      
+      return NextResponse.json({
+        success: true,
+        config: {
+          openaiApiKey: config.openaiApiKey ? maskKey(config.openaiApiKey) : "",
+          anthropicApiKey: config.anthropicApiKey ? maskKey(config.anthropicApiKey) : "",
+          geminiApiKey: config.geminiApiKey ? maskKey(config.geminiApiKey) : "",
+          model: config.model || "claude-3-5-sonnet",
+          extraFlags: config.extraFlags || "",
+          workspaceRoot: config.workspaceRoot || "",
+          scopedDirs: config.scopedDirs || [],
+        },
+      });
+    }
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        openaiApiKey: "",
+        anthropicApiKey: "",
+        geminiApiKey: "",
+        model: "claude-3-5-sonnet",
+        extraFlags: "",
+        workspaceRoot: "",
+        scopedDirs: [],
+      },
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { openaiApiKey, anthropicApiKey, geminiApiKey, model, extraFlags, workspaceRoot, scopedDirs } = body;
+
+    ensureDir();
+
+    let existingConfig = {
+      openaiApiKey: "",
+      anthropicApiKey: "",
+      geminiApiKey: "",
+      model: "claude-3-5-sonnet",
+      extraFlags: "",
+      workspaceRoot: "",
+      scopedDirs: [] as string[],
+    };
+
+    if (fs.existsSync(configPath)) {
+      try {
+        existingConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      } catch (e) {
+        console.error("Failed to parse existing aider.json:", e);
+      }
+    }
+
+    // Determine whether to use new keys or preserve existing ones if masked sentinels are received
+    const finalOpenaiKey = (openaiApiKey && openaiApiKey.includes("...")) 
+      ? existingConfig.openaiApiKey 
+      : (openaiApiKey || "");
+
+    const finalAnthropicKey = (anthropicApiKey && anthropicApiKey.includes("...")) 
+      ? existingConfig.anthropicApiKey 
+      : (anthropicApiKey || "");
+
+    const finalGeminiKey = (geminiApiKey && geminiApiKey.includes("...")) 
+      ? existingConfig.geminiApiKey 
+      : (geminiApiKey || "");
+
+    const newConfig = {
+      openaiApiKey: finalOpenaiKey,
+      anthropicApiKey: finalAnthropicKey,
+      geminiApiKey: finalGeminiKey,
+      model: model || "claude-3-5-sonnet",
+      extraFlags: extraFlags || "",
+      workspaceRoot: workspaceRoot || "",
+      scopedDirs: scopedDirs || [],
+    };
+
+    fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2), "utf8");
+    return NextResponse.json({ success: true, message: "Aider configuration saved successfully!" });
+
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}

package/src/app/api/context/claude/route.ts

@@ -0,0 +1,64 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+const configDir = path.join(process.cwd(), ".ai", "neural-loom");
+const configPath = path.join(configDir, "claude.json");
+
+function ensureDir() {
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+}
+
+export async function GET() {
+  try {
+    if (fs.existsSync(configPath)) {
+      const rawData = fs.readFileSync(configPath, "utf8");
+      const config = JSON.parse(rawData);
+      
+      return NextResponse.json({
+        success: true,
+        config: {
+          name: config.name || "Claude Local",
+          workspaceRoot: config.workspaceRoot || "",
+          scopedDirs: config.scopedDirs || [],
+        },
+      });
+    }
+
+    return NextResponse.json({
+      success: true,
+      config: {
+        name: "Claude Local",
+        workspaceRoot: "",
+        scopedDirs: [],
+      },
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { name, workspaceRoot, scopedDirs } = body;
+
+    ensureDir();
+
+    const newConfig = {
+      name: name || "Claude Local",
+      workspaceRoot: workspaceRoot || "",
+      scopedDirs: scopedDirs || [],
+    };
+
+    fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2), "utf8");
+    return NextResponse.json({ success: true, message: "Claude configuration saved successfully!" });
+
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}

package/src/app/api/context/route.ts

@@ -0,0 +1,37 @@
+import { NextResponse } from "next/server";
+import { ContextManager } from "@/lib/agents/ContextManager";
+
+export async function GET() {
+  try {
+    const prompt = ContextManager.loadPrompt();
+    const rules = ContextManager.loadRules();
+
+    return NextResponse.json({ prompt, rules });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { promptText, rulesText } = body;
+
+    if (promptText !== undefined) {
+      ContextManager.updatePrompt(promptText);
+    }
+
+    if (rulesText !== undefined) {
+      ContextManager.updateRules(rulesText);
+    }
+
+    // Compile global rules context map
+    ContextManager.compileGlobalRules();
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}

package/src/app/api/context/ssh/route.ts

@@ -0,0 +1,88 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+
+const configDir = path.join(process.cwd(), ".ai", "neural-loom");
+const configPath = path.join(configDir, "ssh.json");
+
+function ensureDir() {
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+}
+
+export async function GET() {
+  try {
+    if (fs.existsSync(configPath)) {
+      const data = fs.readFileSync(configPath, "utf8");
+      const config = JSON.parse(data);
+      return NextResponse.json({ success: true, config });
+    }
+    return NextResponse.json({
+      success: true,
+      config: {
+        host: "",
+        port: 22,
+        username: "",
+        privateKeyPath: "",
+      },
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { test, host, port, username, privateKeyPath } = body;
+
+    if (!host || !username) {
+      return NextResponse.json({ success: false, error: "Host and Username are required." }, { status: 400 });
+    }
+
+    const numericPort = port ? parseInt(String(port), 10) : 22;
+
+    if (test) {
+      // Test the SSH connection
+      const success = await new Promise<{ ok: boolean; message: string }>((resolve) => {
+        const keyOpt = privateKeyPath ? `-i "${privateKeyPath}"` : "";
+        const portOpt = `-p ${numericPort}`;
+        
+        // StrictHostKeyChecking=accept-new automatically adds host key to known_hosts if it's new
+        // BatchMode=yes prevents it from waiting for user password prompt
+        const sshCmd = `ssh -o ConnectTimeout=3 -o BatchMode=yes -o StrictHostKeyChecking=accept-new ${keyOpt} ${portOpt} ${username}@${host} "echo CONNECTED"`;
+
+        exec(sshCmd, (error, stdout, stderr) => {
+          if (error) {
+            resolve({ ok: false, message: stderr.trim() || error.message });
+          } else if (stdout.trim().includes("CONNECTED")) {
+            resolve({ ok: true, message: "Successfully connected to remote VM!" });
+          } else {
+            resolve({ ok: false, message: stderr.trim() || "Failed to verify remote host verification print." });
+          }
+        });
+      });
+
+      return NextResponse.json({ success: success.ok, message: success.message });
+    }
+
+    // Save SSH connection configuration
+    ensureDir();
+    const config = {
+      host,
+      port: numericPort,
+      username,
+      privateKeyPath: privateKeyPath || "",
+    };
+
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+    return NextResponse.json({ success: true, message: "SSH configuration saved successfully!" });
+
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ success: false, error: errorMessage }, { status: 500 });
+  }
+}

package/src/app/api/files/route.ts

@@ -0,0 +1,276 @@
+import { NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+
+// Helper to recursively generate a tree nodes list for UI representation
+interface TreeNode {
+  name: string;
+  path: string;
+  type: "file" | "directory";
+  children?: TreeNode[];
+}
+
+function getDirectoryTree(dirPath: string, depth = 0, maxDepth = 3): TreeNode[] {
+  const normDirPath = dirPath.replace(/\\/g, "/");
+  if (depth > maxDepth) return [];
+  try {
+    const items = fs.readdirSync(normDirPath, { withFileTypes: true });
+    const nodes: TreeNode[] = [];
+
+    for (const item of items) {
+      // Skip hidden folders and build folders to keep explorer performant
+      if (
+        item.name.startsWith(".") ||
+        item.name === "node_modules" ||
+        item.name === "out" ||
+        item.name === ".next" ||
+        item.name === "dist"
+      ) {
+        continue;
+      }
+
+      const itemPath = path.join(normDirPath, item.name).replace(/\\/g, "/");
+      if (item.isDirectory()) {
+        nodes.push({
+          name: item.name,
+          path: itemPath,
+          type: "directory",
+          children: getDirectoryTree(itemPath, depth + 1, maxDepth),
+        });
+      } else {
+        nodes.push({
+          name: item.name,
+          path: itemPath,
+          type: "file",
+        });
+      }
+    }
+
+    // Sort: directories first, then files alphabetically
+    return nodes.sort((a, b) => {
+      if (a.type !== b.type) {
+        return a.type === "directory" ? -1 : 1;
+      }
+      return a.name.localeCompare(b.name);
+    });
+  } catch (err) {
+    console.error(`Failed to read directory tree for ${normDirPath}:`, err);
+    return [];
+  }
+}
+
+interface FlatFileItem {
+  name: string;
+  path: string;
+  relativePath: string;
+}
+
+function getFlatFileList(dirPath: string, rootDir: string, list: FlatFileItem[] = [], maxFiles = 1500): FlatFileItem[] {
+  const normDirPath = dirPath.replace(/\\/g, "/");
+  const normRootDir = rootDir.replace(/\\/g, "/");
+  if (list.length >= maxFiles) return list;
+  try {
+    const items = fs.readdirSync(normDirPath, { withFileTypes: true });
+    for (const item of items) {
+      if (list.length >= maxFiles) break;
+
+      // Skip hidden folders and build folders
+      if (
+        item.name.startsWith(".") ||
+        item.name === "node_modules" ||
+        item.name === "out" ||
+        item.name === ".next" ||
+        item.name === "dist"
+      ) {
+        continue;
+      }
+
+      const itemPath = path.join(normDirPath, item.name).replace(/\\/g, "/");
+      if (item.isDirectory()) {
+        getFlatFileList(itemPath, normRootDir, list, maxFiles);
+      } else {
+        const relativePath = path.relative(normRootDir, itemPath).replace(/\\/g, "/");
+        list.push({
+          name: item.name,
+          path: itemPath,
+          relativePath: relativePath,
+        });
+      }
+    }
+  } catch (err) {
+    console.error(`Failed to read flat file list for ${normDirPath}:`, err);
+  }
+  return list;
+}
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const action = searchParams.get("action");
+
+    if (action === "list") {
+      const rootPath = searchParams.get("root");
+      const scopedStr = searchParams.get("scoped");
+      
+      const targetRoot = ((rootPath && fs.existsSync(rootPath)) ? rootPath : process.cwd()).replace(/\\/g, "/");
+      const workspaceTree = getDirectoryTree(targetRoot);
+      const scopedTrees: { name: string; path: string; tree: TreeNode[] }[] = [];
+
+      if (scopedStr) {
+        const scopedPaths = scopedStr.split(",");
+        for (const p of scopedPaths) {
+          const trimmed = p.trim().replace(/\\/g, "/");
+          if (trimmed && fs.existsSync(trimmed)) {
+            scopedTrees.push({
+              name: path.basename(trimmed),
+              path: trimmed,
+              tree: getDirectoryTree(trimmed),
+            });
+          }
+        }
+      }
+
+      return NextResponse.json({
+        success: true,
+        workspace: {
+          name: path.basename(targetRoot) || "Workspace",
+          path: targetRoot,
+          tree: workspaceTree,
+        },
+        scoped: scopedTrees,
+      });
+    }
+
+    if (action === "flat_list") {
+      const rootPath = searchParams.get("root");
+      const scopedStr = searchParams.get("scoped");
+      
+      const targetRoot = ((rootPath && fs.existsSync(rootPath)) ? rootPath : process.cwd()).replace(/\\/g, "/");
+      const files: FlatFileItem[] = [];
+      
+      getFlatFileList(targetRoot, targetRoot, files);
+
+      if (scopedStr) {
+        const scopedPaths = scopedStr.split(",");
+        for (const p of scopedPaths) {
+          const trimmed = p.trim().replace(/\\/g, "/");
+          if (trimmed && fs.existsSync(trimmed)) {
+            getFlatFileList(trimmed, path.dirname(trimmed).replace(/\\/g, "/"), files);
+          }
+        }
+      }
+
+      return NextResponse.json({
+        success: true,
+        files: files,
+      });
+    }
+
+    if (action === "read") {
+      const filePathRaw = searchParams.get("path");
+      if (!filePathRaw) {
+        return NextResponse.json({ error: "Missing required parameter 'path'" }, { status: 400 });
+      }
+
+      const filePath = filePathRaw.replace(/\\/g, "/");
+      if (!fs.existsSync(filePath)) {
+        return NextResponse.json({ error: "File does not exist" }, { status: 404 });
+      }
+
+      const content = fs.readFileSync(filePath, "utf8");
+      return NextResponse.json({ success: true, content });
+    }
+
+    return NextResponse.json({ error: "Invalid action. Must be 'list', 'flat_list' or 'read'" }, { status: 400 });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    const { action, path: rawPath, content, type, oldPath: rawOldPath, newPath: rawNewPath } = body;
+    const filePath = rawPath ? rawPath.replace(/\\/g, "/") : undefined;
+    const oldPath = rawOldPath ? rawOldPath.replace(/\\/g, "/") : undefined;
+    const newPath = rawNewPath ? rawNewPath.replace(/\\/g, "/") : undefined;
+
+    if (action === "write") {
+      if (!filePath || content === undefined) {
+        return NextResponse.json({ error: "Missing 'path' or 'content' in body" }, { status: 400 });
+      }
+
+      // Ensure target directory exists
+      const parentDir = path.dirname(filePath).replace(/\\/g, "/");
+      if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+      }
+
+      fs.writeFileSync(filePath, content, "utf8");
+      return NextResponse.json({ success: true, message: "File saved successfully" });
+    }
+
+    if (action === "create") {
+      if (!filePath || !type) {
+        return NextResponse.json({ error: "Missing 'path' or 'type' in request body" }, { status: 400 });
+      }
+
+      if (fs.existsSync(filePath)) {
+        return NextResponse.json({ error: "Path already exists" }, { status: 400 });
+      }
+
+      if (type === "directory") {
+        fs.mkdirSync(filePath, { recursive: true });
+        return NextResponse.json({ success: true, message: "Directory created successfully" });
+      } else {
+        const parentDir = path.dirname(filePath).replace(/\\/g, "/");
+        if (!fs.existsSync(parentDir)) {
+          fs.mkdirSync(parentDir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, "", "utf8");
+        return NextResponse.json({ success: true, message: "File created successfully" });
+      }
+    }
+
+    if (action === "rename") {
+      if (!oldPath || !newPath) {
+        return NextResponse.json({ error: "Missing 'oldPath' or 'newPath' in request body" }, { status: 400 });
+      }
+
+      if (!fs.existsSync(oldPath)) {
+        return NextResponse.json({ error: "Source path does not exist" }, { status: 404 });
+      }
+
+      if (fs.existsSync(newPath)) {
+        return NextResponse.json({ error: "Target path already exists" }, { status: 400 });
+      }
+
+      const parentDir = path.dirname(newPath).replace(/\\/g, "/");
+      if (!fs.existsSync(parentDir)) {
+        fs.mkdirSync(parentDir, { recursive: true });
+      }
+
+      fs.renameSync(oldPath, newPath);
+      return NextResponse.json({ success: true, message: "Renamed successfully" });
+    }
+
+    if (action === "delete") {
+      if (!filePath) {
+        return NextResponse.json({ error: "Missing 'path' in request body" }, { status: 400 });
+      }
+
+      if (!fs.existsSync(filePath)) {
+        return NextResponse.json({ error: "Path does not exist" }, { status: 404 });
+      }
+
+      fs.rmSync(filePath, { recursive: true, force: true });
+      return NextResponse.json({ success: true, message: "Deleted successfully" });
+    }
+
+    return NextResponse.json({ error: "Invalid action." }, { status: 400 });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}

package/src/app/api/git/route.ts

@@ -0,0 +1,81 @@
+import { NextResponse } from "next/server";
+import { promisify } from "util";
+import { exec } from "child_process";
+import fs from "fs";
+import path from "path";
+
+const execPromise = promisify(exec);
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const action = searchParams.get("action");
+    const rootPath = searchParams.get("root");
+    const file = searchParams.get("file");
+
+    const targetRoot = ((rootPath && fs.existsSync(rootPath)) ? rootPath : process.cwd()).replace(/\\/g, "/");
+
+    // Check if it's a git repo
+    try {
+      await execPromise("git rev-parse --is-inside-work-tree", { cwd: targetRoot });
+    } catch {
+      return NextResponse.json({ success: true, isGit: false, files: [] });
+    }
+
+    if (action === "status") {
+      const { stdout } = await execPromise("git status --porcelain", { cwd: targetRoot });
+      const lines = stdout.split(/\r?\n/).filter(Boolean);
+      const files = lines.map(line => {
+        // porcelain format: XY path or XY "path"
+        const status = line.substring(0, 2);
+        let relativePath = line.substring(3).trim();
+        // Remove quotes if git quoted the path
+        if (relativePath.startsWith('"') && relativePath.endsWith('"')) {
+          relativePath = relativePath.slice(1, -1);
+        }
+        const absolutePath = path.join(targetRoot, relativePath).replace(/\\/g, "/");
+        return {
+          status: status.trim(),
+          relativePath,
+          absolutePath,
+          name: path.basename(relativePath)
+        };
+      });
+
+      return NextResponse.json({ success: true, isGit: true, files });
+    }
+
+    if (action === "diff") {
+      if (!file) {
+        return NextResponse.json({ error: "Missing file parameter" }, { status: 400 });
+      }
+
+      const absolutePath = path.resolve(targetRoot, file).replace(/\\/g, "/");
+      if (!fs.existsSync(absolutePath)) {
+        return NextResponse.json({ error: "File not found" }, { status: 404 });
+      }
+
+      // Check status to see if it is untracked
+      const { stdout: statusOut } = await execPromise("git status --porcelain -- " + JSON.stringify(file), { cwd: targetRoot });
+      const isUntracked = statusOut.startsWith("??");
+
+      if (isUntracked) {
+        const fileContent = fs.readFileSync(absolutePath, "utf8");
+        const diffLines = fileContent.split(/\r?\n/).map(l => "+" + l).join("\n");
+        return NextResponse.json({ success: true, diff: diffLines });
+      } else {
+        try {
+          const { stdout: diffOut } = await execPromise(`git diff --no-color -- ${JSON.stringify(file)}`, { cwd: targetRoot });
+          return NextResponse.json({ success: true, diff: diffOut });
+        } catch {
+          return NextResponse.json({ success: true, diff: `Binary file or diff unavailable.` });
+        }
+      }
+    }
+
+    return NextResponse.json({ error: "Invalid action" }, { status: 400 });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}