Create server.js

server.js

@@ -0,0 +1,595 @@
+const express = require("express");
+const multer = require("multer");
+const fs = require("fs");
+const path = require("path");
+const { exec } = require("child_process");
+const cors = require("cors");
+const axios = require("axios");
+
+const app = express();
+const PORT = 3000;
+const HOME_DIR = path.join(__dirname, "home");
+const TASK_FILE = path.join(HOME_DIR, ".zoro_tasks.txt");
+
+if (!fs.existsSync(HOME_DIR)) fs.mkdirSync(HOME_DIR, { recursive: true });
+
+app.use(cors());
+app.use(express.json({ limit: "10mb" }));
+app.use(express.static(path.join(__dirname, "public")));
+
+// ── Multer ─────────────────────────────────────────────────────────────────
+const storage = multer.diskStorage({
+  destination: HOME_DIR,
+  filename: (req, file, cb) => cb(null, "index.js"),
+});
+const upload = multer({ storage });
+
+// ── ALLOWED COMMANDS ───────────────────────────────────────────────────────
+const ALLOWED_CMDS = [
+  "grep", "sed", "awk", "head", "tail", "cat", "wc",
+  "sort", "uniq", "cut", "tr", "find", "ls", "echo",
+  "diff", "patch", "node", "npm", "file", "stat",
+];
+
+const COMMANDS_REFERENCE = `
+=== SHELL COMMANDS AVAILABLE (cwd = /home) ===
+
+FILE EXPLORATION:
+  ls -l                           List files & directories
+  find . -name "*.js"             Find JS files recursively
+  find . -name "*.json"           Find config files
+  file filename                   Show file type
+  stat filename                   File metadata (size, dates)
+
+READING CONTENT:
+  cat file                        Read entire file
+  head -n N file                  First N lines
+  tail -n N file                  Last N lines
+  sed -n 'X,Yp' file              Lines X to Y (surgical)
+  head -c N file                  First N bytes
+  grep -n "pattern" file          Lines matching pattern (with line numbers)
+  grep -A5 "pattern" file         Pattern + 5 lines after
+  grep -B3 "pattern" file         Pattern + 3 lines before
+  grep -C3 "pattern" file         Pattern + 3 lines context (before+after)
+  grep -rn "pattern" .            Recursive search all files
+
+COUNTING / STATS:
+  wc -l file                      Count lines
+  grep -c "pattern" file          Count occurrences
+  awk 'END{print NR}' file        Alternative line count
+
+EDITING (surgical, safe):
+  sed -i 's/old/new/g' file       Replace ALL occurrences
+  sed -i '12s/old/new/' file      Replace on line 12 ONLY
+  sed -i 'X,Ys/old/new/g' file    Replace in lines X–Y
+  awk '/pattern/' file            Extract matching lines
+  cut -d',' -f2 file              Extract 2nd CSV column
+  tr 'a-z' 'A-Z'                  Transform chars
+
+COMPARING:
+  diff old.js new.js              Show differences between files
+  patch file < patchfile          Apply a patch file
+
+SYNTAX / ERROR CHECKING:
+  node --check file.js            JavaScript syntax validation
+  npm test                        Run project tests
+
+PROJECT INFO:
+  cat package.json                Show project dependencies
+  npm run scriptname              Run npm scripts
+
+UTILITIES:
+  echo "text"                     Print text
+  sort file                       Sort lines alphabetically
+  uniq file                       Remove duplicate lines
+
+=== AGENT RULES ===
+1. ALWAYS run "node --check file.js" BEFORE any edit
+2. ALWAYS run "node --check file.js" AFTER any edit
+3. Use grep -C3 to understand context BEFORE inserting new code
+4. Match existing code style — grep for similar patterns first
+5. Use sed -n 'X,Yp' to read specific sections before modifying them
+6. Back up important sections mentally before sed -i changes
+7. For adding new features: grep for existing similar features first
+===============================================
+`;
+
+// ── File Tree ──────────────────────────────────────────────────────────────
+app.get("/api/tree", (req, res) => {
+  const buildTree = (dir, base = HOME_DIR) => {
+    try {
+      return fs.readdirSync(dir, { withFileTypes: true })
+        .filter(e => !e.name.startsWith(".zoro_"))
+        .map(e => {
+          const relPath = path.relative(base, path.join(dir, e.name));
+          if (e.isDirectory()) {
+            return { type: "dir", name: e.name, path: relPath, children: buildTree(path.join(dir, e.name), base) };
+          }
+          const stats = fs.statSync(path.join(dir, e.name));
+          return { type: "file", name: e.name, path: relPath, size: stats.size };
+        });
+    } catch { return []; }
+  };
+  try { res.json({ tree: buildTree(HOME_DIR) }); }
+  catch { res.json({ tree: [] }); }
+});
+
+app.post("/api/upload", upload.single("file"), (req, res) => {
+  res.json({ success: true, path: "index.js" });
+});
+
+app.get("/api/file", (req, res) => {
+  const fp = path.join(HOME_DIR, req.query.path || "index.js");
+  if (!fp.startsWith(HOME_DIR)) return res.status(403).json({ error: "Forbidden" });
+  if (!fs.existsSync(fp)) return res.status(404).json({ error: "Not found" });
+  res.json({ content: fs.readFileSync(fp, "utf8") });
+});
+
+app.post("/api/file", (req, res) => {
+  const { filePath, content } = req.body;
+  const abs = path.join(HOME_DIR, filePath);
+  if (!abs.startsWith(HOME_DIR)) return res.status(403).json({ error: "Forbidden" });
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, content, "utf8");
+  res.json({ success: true });
+});
+
+app.delete("/api/file", (req, res) => {
+  const { filePath } = req.body;
+  const abs = path.join(HOME_DIR, filePath);
+  if (!abs.startsWith(HOME_DIR)) return res.status(403).json({ error: "Forbidden" });
+  if (fs.existsSync(abs)) fs.unlinkSync(abs);
+  res.json({ success: true });
+});
+
+app.get("/api/download", (req, res) => {
+  const fp = path.join(HOME_DIR, req.query.path);
+  if (!fp.startsWith(HOME_DIR)) return res.status(403).json({ error: "Forbidden" });
+  if (!fs.existsSync(fp)) return res.status(404).json({ error: "Not found" });
+  res.download(fp);
+});
+
+app.get("/api/tasks", (req, res) => {
+  if (!fs.existsSync(TASK_FILE)) return res.json({ tasks: [] });
+  res.json({ tasks: readTaskLog() });
+});
+
+// ── Execute command ────────────────────────────────────────────────────────
+app.post("/api/exec", (req, res) => {
+  const { command } = req.body;
+  const cmdName = command.trim().split(/\s+/)[0];
+  if (!ALLOWED_CMDS.includes(cmdName)) {
+    return res.json({ stdout: "", stderr: `'${cmdName}' not in allowed commands.`, code: 1 });
+  }
+  exec(command, { cwd: HOME_DIR, timeout: 15000 }, (err, stdout, stderr) => {
+    res.json({ stdout: stdout || "", stderr: stderr || "", code: err ? (err.code || 1) : 0 });
+  });
+});
+
+// ── Core Helpers ───────────────────────────────────────────────────────────
+
+async function callAI(system, query) {
+  const params = new URLSearchParams({ BK9: system, q: query, model: "compound-beta-mini" });
+  const { data } = await axios.get(`https://api.bk9.dev/ai/BK94?${params}`, { timeout: 30000 });
+  return data.BK9 || data.response || data.message || "";
+}
+
+function parseJSON(raw) {
+  if (!raw) return null;
+  let s = raw.replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
+  const m = s.match(/\{[\s\S]*\}/);
+  if (m) s = m[0];
+  try { return JSON.parse(s); } catch { return null; }
+}
+
+function runCmd(command) {
+  return new Promise(resolve => {
+    const name = command.trim().split(/\s+/)[0];
+    if (!ALLOWED_CMDS.includes(name)) {
+      return resolve({ stdout: "", stderr: `Not allowed: ${name}`, code: 1 });
+    }
+    exec(command, { cwd: HOME_DIR, timeout: 15000 }, (err, stdout, stderr) => {
+      resolve({ stdout: stdout || "", stderr: stderr || "", code: err ? (err.code || 1) : 0 });
+    });
+  });
+}
+
+function backupFile(filePath) {
+  const src = path.join(HOME_DIR, filePath);
+  if (!fs.existsSync(src)) return;
+  const dst = path.join(HOME_DIR, filePath.replace(/(\.\w+)?$/, "_backup$1"));
+  fs.copyFileSync(src, dst);
+}
+
+// Smart context: for big files, find relevant section using query keywords
+function getSmartContext(content, query, maxLines = 120) {
+  const lines = content.split("\n");
+  if (lines.length <= maxLines) return content;
+
+  const head = lines.slice(0, 40).join("\n");
+  const tail = lines.slice(-15).join("\n");
+  const words = query.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+
+  let rs = -1, re = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const lower = lines[i].toLowerCase();
+    if (words.some(w => lower.includes(w))) {
+      if (rs === -1) rs = Math.max(0, i - 5);
+      re = Math.min(lines.length - 1, i + 35);
+    }
+  }
+
+  const middle = rs !== -1
+    ? `\n// ... [lines 41–${rs} omitted] ...\n` + lines.slice(rs, re + 1).join("\n") + `\n// ... [lines ${re + 1} onward omitted] ...\n`
+    : `\n// ... [${lines.length - 55} lines omitted] ...\n`;
+
+  return head + middle + tail;
+}
+
+// Task log
+function updateTaskLog(tasks) {
+  const lines = ["=== ZORO TASK LOG ===", `Updated: ${new Date().toISOString()}`, ""];
+  for (const t of tasks) {
+    lines.push(`[${t.done ? "✅" : "⬜"}] ${t.task}`);
+    if (t.note) lines.push(`     → ${t.note}`);
+  }
+  fs.writeFileSync(TASK_FILE, lines.join("\n"), "utf8");
+}
+
+function readTaskLog() {
+  if (!fs.existsSync(TASK_FILE)) return [];
+  return fs.readFileSync(TASK_FILE, "utf8").split("\n")
+    .map(l => l.match(/^\[(✅|⬜)\] (.+)/))
+    .filter(Boolean)
+    .map(m => ({ done: m[1] === "✅", task: m[2] }));
+}
+
+// Run syntax check, auto-fix loop up to maxAttempts times
+async function syntaxFixLoop(filePath, send, maxAttempts = 3) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const check = await runCmd(`node --check ${filePath}`);
+    const cmdIdx = 800 + attempt;
+
+    send("command", { cmd: `node --check ${filePath} (attempt ${attempt})`, index: cmdIdx });
+    send("command_result", {
+      cmd: `node --check ${filePath}`,
+      stdout: check.code === 0 ? "✓ Syntax OK" : "",
+      stderr: check.stderr,
+      index: cmdIdx,
+      isError: check.code !== 0
+    });
+
+    if (check.code === 0) {
+      if (attempt === 1) send("status", { text: `✅ Syntax OK` });
+      else send("status", { text: `✅ Syntax fixed on attempt ${attempt}` });
+      return true;
+    }
+
+    send("status", { text: `⚠️ Syntax error (attempt ${attempt}/${maxAttempts}) — fixing...` });
+
+    const absPath = path.join(HOME_DIR, filePath);
+    const broken = fs.readFileSync(absPath, "utf8");
+
+    const fixedRaw = await callAI(
+      `You are Zoro - a precise JS developer. Fix the syntax error. Return ONLY valid JSON with no extra text: {"content":"fixed file here","fix":"what was wrong"}`,
+      `File: ${filePath}\nError:\n${check.stderr}\n\nFile content:\n${broken}`
+    );
+
+    const fixed = parseJSON(fixedRaw);
+    if (fixed?.content) {
+      fs.writeFileSync(absPath, fixed.content, "utf8");
+      send("status", { text: `🔨 Applied fix: ${fixed.fix || "syntax correction"}` });
+    } else {
+      send("status", { text: `⚠️ Could not auto-fix on attempt ${attempt}` });
+      break;
+    }
+  }
+  return false;
+}
+
+// ── MAIN CHAT ENDPOINT ─────────────────────────────────────────────────────
+app.post("/api/chat", async (req, res) => {
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+
+  const send = (type, data) => {
+    try { res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`); } catch {}
+  };
+
+  const { message, currentFile } = req.body;
+
+  try {
+    let filePath = currentFile || "index.js";
+    const absPath = path.join(HOME_DIR, filePath);
+    let fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : "";
+    const hasFile = fileContent.length > 0;
+    const fileLines = fileContent.split("\n").length;
+
+    // ══════════════════════════════════════════════════════════════════════
+    // CASE 1: No file → create from scratch
+    // ══════════════════════════════════════════════════════════════════════
+    if (!hasFile) {
+      send("status", { text: "🧠 Planning what to build..." });
+
+      const aiRaw = await callAI(
+        `You are Zoro from One Piece - a sharp, direct developer AI.
+Create the code the user asks for. First plan tasks, then generate the complete file.
+Return ONLY valid JSON (no markdown fences, no backticks, no extra text):
+{
+  "filename": "index.js",
+  "description": "what this file is",
+  "tasks": [{"task": "what you did", "done": true}],
+  "content": "complete file content",
+  "status": "Done - what was built"
+}`,
+        message
+      );
+
+      let parsed = parseJSON(aiRaw);
+      if (!parsed?.content) {
+        parsed = {
+          filename: "index.js",
+          content: aiRaw,
+          description: "Generated",
+          tasks: [{ task: "Generate file from request", done: true }],
+          status: "Created file",
+        };
+      }
+
+      send("status", { text: `📋 Plan ready — ${parsed.tasks?.length || 1} tasks` });
+      send("task_update", { tasks: parsed.tasks || [] });
+
+      // Syntax check generated code
+      send("status", { text: "🔍 Checking generated code..." });
+      const tmpName = "__zoro_new_check.js";
+      const tmpPath = path.join(HOME_DIR, tmpName);
+      fs.writeFileSync(tmpPath, parsed.content, "utf8");
+
+      const syntaxOk = await syntaxFixLoop(tmpName, send, 3);
+      // Read back (may have been fixed)
+      parsed.content = fs.readFileSync(tmpPath, "utf8");
+      fs.unlinkSync(tmpPath);
+
+      send("status", { text: `💾 Saving ${parsed.filename}...` });
+      const savePath = path.join(HOME_DIR, parsed.filename);
+      fs.mkdirSync(path.dirname(savePath), { recursive: true });
+      fs.writeFileSync(savePath, parsed.content, "utf8");
+
+      // Final verify on saved path
+      const finalCheck = await runCmd(`node --check ${parsed.filename}`);
+      send("command", { cmd: `node --check ${parsed.filename}`, index: 0 });
+      send("command_result", {
+        cmd: `node --check ${parsed.filename}`,
+        stdout: finalCheck.code === 0 ? "✓ Syntax OK — file saved!" : "",
+        stderr: finalCheck.stderr,
+        index: 0,
+        isError: finalCheck.code !== 0
+      });
+
+      updateTaskLog(parsed.tasks || []);
+      send("file_created", { filename: parsed.filename, content: parsed.content, description: parsed.description });
+      send("message", { text: `✅ Created \`${parsed.filename}\` — ${parsed.description}` });
+      send("tree_update", {});
+      res.write("data: [DONE]\n\n");
+      res.end();
+      return;
+    }
+
+    // ══════════════════════════════════════════════════════════════════════
+    // CASE 2: File exists — analyze + command loop + edit/answer
+    // ══════════════════════════════════════════════════════════════════════
+    send("status", { text: "🗺️ Analyzing request..." });
+
+    const smartCtx = getSmartContext(fileContent, message);
+    const existingTasks = readTaskLog();
+    const pendingTasks = existingTasks.filter(t => !t.done);
+
+    const masterPlanRaw = await callAI(
+      `You are Zoro - a razor-sharp developer AI agent operating on code files.
+You use shell commands to explore, understand, then modify code.
+
+${COMMANDS_REFERENCE}
+
+WORKFLOW FOR EDITS:
+1. EXPLORE: grep for existing patterns similar to what user wants
+2. LOCATE: find exact line numbers (grep -n, wc -l, sed -n to read sections)
+3. UNDERSTAND: read context around insertion points (grep -C5)
+4. CHECK: node --check before any edit
+5. EDIT: surgical sed -i on specific lines
+6. VERIFY: node --check after edit
+
+WORKFLOW FOR QUERIES:
+1. grep for relevant functions/patterns
+2. read surrounding context
+3. answer precisely
+
+File: ${filePath} (${fileLines} lines)
+Current content preview:
+${smartCtx.substring(0, 2500)}
+
+${pendingTasks.length > 0 ? `UNFINISHED TASKS FROM LAST SESSION:\n${pendingTasks.map(t => `  ⬜ ${t.task}`).join("\n")}\n` : ""}
+
+Respond ONLY with valid JSON (no markdown):
+{
+  "task_type": "query" | "edit" | "create",
+  "status": "brief description shown to user",
+  "tasks": [{"task": "subtask name", "done": false}],
+  "commands": ["cmd1", "cmd2"],
+  "reasoning": "why these commands in this order"
+}`,
+      message
+    );
+
+    let plan = parseJSON(masterPlanRaw);
+    if (!plan) plan = { task_type: "query", status: "Analyzing...", tasks: [], commands: [], reasoning: "" };
+
+    send("status", { text: `⚡ ${plan.status || "Processing..."}` });
+    if (plan.tasks?.length > 0) send("task_update", { tasks: plan.tasks });
+
+    // Run all planned commands
+    const commandResults = [];
+    for (let i = 0; i < (plan.commands || []).length; i++) {
+      const cmd = plan.commands[i];
+      send("status", { text: `🔧 [${i + 1}/${plan.commands.length}] \`${cmd}\`` });
+      send("command", { cmd, index: i });
+
+      const result = await runCmd(cmd);
+      commandResults.push({ cmd, ...result });
+
+      send("command_result", {
+        cmd,
+        stdout: result.stdout.substring(0, 1000),
+        stderr: result.stderr.substring(0, 500),
+        index: i,
+        isError: result.code !== 0 && !!result.stderr
+      });
+
+      // If node --check failed here, enter fix loop immediately
+      if (cmd.includes("node --check") && result.code !== 0 && result.stderr) {
+        const targetFile = cmd.split(/\s+/).pop();
+        send("status", { text: `⚠️ Syntax error found in ${targetFile} — entering fix loop...` });
+        await syntaxFixLoop(targetFile, send, 3);
+        // Re-read file after fixes
+        fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+      }
+    }
+
+    // Re-read file (sed -i may have modified it)
+    fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+
+    const resultsText = commandResults
+      .map(r => `$ ${r.cmd}\n${r.stdout.substring(0, 600)}${r.stderr ? `\nSTDERR: ${r.stderr.substring(0, 300)}` : ""}`)
+      .join("\n\n");
+
+    // ── Final step: synthesize answer or produce edited file ───────────────
+    send("status", { text: "🧠 Synthesizing..." });
+
+    if (plan.task_type === "query") {
+      const ansRaw = await callAI(
+        `You are Zoro from One Piece - direct, precise, no-nonsense developer.
+Answer the user's question based on file content and command results.
+Return ONLY valid JSON: {"answer": "clear precise answer", "status": "Done"}`,
+        `Question: "${message}"\nFile: ${filePath}\nResults:\n${resultsText}\nContext:\n${smartCtx.substring(0, 2000)}`
+      );
+      const ans = parseJSON(ansRaw);
+      send("message", { text: ans?.answer || ansRaw || "No answer generated." });
+
+    } else {
+      // Edit or create — produce full updated file
+      const hadSedEdits = commandResults.some(r => r.cmd.startsWith("sed -i") && r.code === 0);
+
+      if (hadSedEdits) {
+        // File was already modified by sed — run fix loop, then report
+        send("status", { text: "🔍 Verifying sed edits..." });
+        await syntaxFixLoop(filePath, send, 3);
+        fileContent = fs.readFileSync(absPath, "utf8");
+
+        const sumRaw = await callAI(
+          `You are Zoro. Summarize what changed in the file. Return ONLY JSON: {"summary": "what changed", "tasks_completed": ["t1", "t2"]}`,
+          `User asked: ${message}\nCommands:\n${resultsText}`
+        );
+        const sum = parseJSON(sumRaw);
+
+        const allTasks = [
+          ...existingTasks.map(t => ({ ...t, done: true })),
+          ...(plan.tasks || []).map(t => ({ ...t, done: true }))
+        ];
+        updateTaskLog(allTasks);
+        send("task_update", { tasks: allTasks });
+
+        send("file_updated", { filename: filePath, content: fileContent, description: sum?.summary || "Updated" });
+        send("message", { text: `✅ ${sum?.summary || "Changes applied via sed"}` });
+
+      } else {
+        // AI produces the full new file content
+        const editRaw = await callAI(
+          `You are Zoro - a precise developer AI.
+You have explored the file with commands. Now produce the complete updated file.
+
+KEY RULES:
+- Study command results carefully — they show existing code patterns
+- Match the EXACT style, indentation, naming conventions of existing code
+- For new features/commands: model them exactly after existing similar ones
+- Make ONLY the necessary changes, preserve everything else
+- The output must be a complete, working file
+
+Return ONLY valid JSON (no markdown):
+{
+  "content": "COMPLETE updated file content here",
+  "description": "what changed",
+  "tasks_completed": ["task1", "task2"],
+  "status": "Done — what was accomplished"
+}`,
+          `User request: "${message}"
+File: ${filePath} (${fileLines} lines)
+Current file:
+${fileContent.substring(0, 5000)}
+Command exploration results:
+${resultsText}
+Produce the complete updated file.`
+        );
+
+        let editParsed = parseJSON(editRaw);
+        if (!editParsed?.content) {
+          editParsed = { content: fileContent, description: "No changes", status: "Done", tasks_completed: [] };
+        }
+
+        // Back up before saving
+        backupFile(filePath);
+
+        // Pre-save syntax check
+        send("status", { text: "🔍 Checking new content before saving..." });
+        const tmpName = `__zoro_presave_${Date.now()}.js`;
+        const tmpPath = path.join(HOME_DIR, tmpName);
+        fs.writeFileSync(tmpPath, editParsed.content, "utf8");
+
+        const preOk = await syntaxFixLoop(tmpName, send, 3);
+        editParsed.content = fs.readFileSync(tmpPath, "utf8");
+        fs.unlinkSync(tmpPath);
+
+        // Save
+        fs.writeFileSync(absPath, editParsed.content, "utf8");
+        send("status", { text: `💾 Saved ${filePath}` });
+
+        // Post-save verify
+        await syntaxFixLoop(filePath, send, 3);
+        fileContent = fs.readFileSync(absPath, "utf8");
+
+        // Update task log
+        const allTasks = [
+          ...existingTasks.map(t => ({ ...t, done: true })),
+          ...(plan.tasks || []).map(t => ({ ...t, done: true, note: "done this session" }))
+        ];
+        updateTaskLog(allTasks);
+        send("task_update", { tasks: allTasks });
+
+        send("file_updated", { filename: filePath, content: fileContent, description: editParsed.description });
+        send("message", { text: `✅ ${editParsed.status || editParsed.description}` });
+        send("tree_update", {});
+      }
+    }
+
+    // Check for unfinished tasks
+    const latestTasks = readTaskLog();
+    const stillPending = latestTasks.filter(t => !t.done);
+    if (stillPending.length > 0) {
+      send("status", { text: `📋 ${stillPending.length} tasks still pending` });
+      send("pending_tasks", { tasks: stillPending, count: stillPending.length });
+    }
+
+    res.write("data: [DONE]\n\n");
+    res.end();
+
+  } catch (err) {
+    console.error("Chat error:", err);
+    send("error", { text: err.message });
+    res.write("data: [DONE]\n\n");
+    res.end();
+  }
+});
+
+app.listen(PORT, () => {
+  console.log(`\n🗡️  Zoro Dev Server → http://localhost:${PORT}`);
+  console.log(`📁  Home dir: ${HOME_DIR}\n`);
+});