daemora 1.0.0

package/src/tools/editFile.js

@@ -0,0 +1,139 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+/**
+ * Multi-strategy file editing — inspired by Gemini CLI.
+ *
+ * Strategy chain:
+ * 1. EXACT match — direct string replacement
+ * 2. FLEXIBLE match — line-by-line, ignoring leading/trailing whitespace
+ * 3. If all fail — show helpful error with nearby context
+ */
+
+function exactMatch(content, oldString, newString) {
+  if (!content.includes(oldString)) return null;
+  const occurrences = content.split(oldString).length - 1;
+  const updated = content.replaceAll(oldString, newString);
+  return { updated, occurrences, strategy: "exact" };
+}
+
+function flexibleMatch(content, oldString, newString) {
+  const contentLines = content.split("\n");
+  const searchLines = oldString.split("\n").map((l) => l.trim());
+
+  // Find the search block in content, comparing trimmed lines
+  for (let i = 0; i <= contentLines.length - searchLines.length; i++) {
+    let match = true;
+    for (let j = 0; j < searchLines.length; j++) {
+      if (contentLines[i + j].trim() !== searchLines[j]) {
+        match = false;
+        break;
+      }
+    }
+
+    if (match) {
+      // Preserve the indentation of the first matched line
+      const indent = contentLines[i].match(/^(\s*)/)[1];
+      const newLines = newString.split("\n").map((line, idx) => {
+        if (idx === 0) return indent + line.trimStart();
+        return indent + line; // keep relative indentation from newString
+      });
+
+      const result = [
+        ...contentLines.slice(0, i),
+        ...newLines,
+        ...contentLines.slice(i + searchLines.length),
+      ];
+
+      return { updated: result.join("\n"), occurrences: 1, strategy: "flexible" };
+    }
+  }
+  return null;
+}
+
+function findNearbyContext(content, oldString, maxContext = 3) {
+  const lines = content.split("\n");
+  const searchFirstLine = oldString.split("\n")[0].trim();
+
+  // Find lines similar to the first line of oldString
+  const candidates = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().includes(searchFirstLine.slice(0, 30))) {
+      const start = Math.max(0, i - maxContext);
+      const end = Math.min(lines.length, i + maxContext + 1);
+      candidates.push({
+        lineNumber: i + 1,
+        context: lines
+          .slice(start, end)
+          .map((l, idx) => `${start + idx + 1} | ${l}`)
+          .join("\n"),
+      });
+    }
+  }
+  return candidates.slice(0, 3);
+}
+
+export function editFile(filePath, oldString, newString) {
+  // Parameter validation — model sometimes passes wrong number of args
+  if (!filePath || typeof filePath !== "string") {
+    return "Error: editFile requires filePath as the first parameter.";
+  }
+  if (!oldString || typeof oldString !== "string") {
+    return "Error: editFile requires oldString as the second parameter — the text to find and replace.";
+  }
+  if (newString === undefined || newString === null || typeof newString !== "string") {
+    return "Error: editFile requires 3 parameters: editFile(filePath, oldString, newString). You only passed 2. oldString is the text to FIND in the file, newString is what to REPLACE it with. If you want to append content, use writeFile instead to rewrite the full file, or use editFile with an existing line as oldString and provide the replacement that includes the new content.";
+  }
+
+  // Filesystem security check
+  const guard = filesystemGuard.checkWrite(filePath);
+  if (!guard.allowed) {
+    console.log(`      [editFile] BLOCKED: ${guard.reason}`);
+    return guard.reason;
+  }
+
+  console.log(`      [editFile] File: ${filePath}`);
+  console.log(`      [editFile] Find: "${oldString.slice(0, 60)}${oldString.length > 60 ? "..." : ""}"`);
+  console.log(`      [editFile] Replace: "${newString.slice(0, 60)}${newString.length > 60 ? "..." : ""}"`);
+
+  try {
+    const content = readFileSync(filePath, { encoding: "utf-8" });
+
+    // Strategy 1: Exact match
+    let result = exactMatch(content, oldString, newString);
+    if (result) {
+      writeFileSync(filePath, result.updated, { encoding: "utf-8" });
+      console.log(`      [editFile] Done — ${result.strategy} match, replaced ${result.occurrences} occurrence(s)`);
+      return `File ${filePath} edited successfully (${result.strategy} match). Replaced ${result.occurrences} occurrence(s).`;
+    }
+
+    // Strategy 2: Flexible match (whitespace-tolerant)
+    result = flexibleMatch(content, oldString, newString);
+    if (result) {
+      writeFileSync(filePath, result.updated, { encoding: "utf-8" });
+      console.log(`      [editFile] Done — ${result.strategy} match`);
+      return `File ${filePath} edited successfully (${result.strategy} match). Replaced ${result.occurrences} occurrence(s).`;
+    }
+
+    // All strategies failed — provide helpful error
+    const nearby = findNearbyContext(content, oldString);
+    let errorMsg = `Error: Could not find the string to replace in ${filePath}.\n`;
+    errorMsg += `Make sure oldString matches the file content (including whitespace/indentation).\n`;
+
+    if (nearby.length > 0) {
+      errorMsg += `\nSimilar content found near:\n`;
+      for (const c of nearby) {
+        errorMsg += `\n--- Line ${c.lineNumber} ---\n${c.context}\n`;
+      }
+    }
+
+    console.log(`      [editFile] Failed — no match found`);
+    return errorMsg;
+  } catch (error) {
+    console.log(`      [editFile] Failed: ${error.message}`);
+    return `Error editing file: ${error.message}`;
+  }
+}
+
+export const editFileDescription =
+  "editFile(filePath: string, oldString: string, newString: string) - Finds oldString in the file and replaces ALL occurrences with newString. Supports exact and flexible matching (whitespace-tolerant). Shows nearby context on failure.";

package/src/tools/executeCommand.js

@@ -0,0 +1,123 @@
+/**
+ * executeCommand(cmd, optionsJson?) — Execute a shell command with advanced options.
+ * Upgraded from 23-line basic version to support: cwd, timeout, env, background mode, stderr.
+ *
+ * Filesystem scoping:
+ * - If ALLOWED_PATHS is set, the cwd of every command must be within an allowed directory.
+ * - If RESTRICT_COMMANDS=true, absolute paths referenced in the command string are also checked.
+ *   This prevents "cd / && rm -rf ~/Desktop" style escapes when scoped mode is active.
+ */
+import { execSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { config } from "../config/default.js";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+const DEFAULT_TIMEOUT_MS = 120_000;   // 2 minutes default
+const MAX_TIMEOUT_MS = 600_000;       // 10 minutes hard max
+const MAX_BUFFER = 10 * 1024 * 1024; // 10MB
+
+export function executeCommand(cmd, optionsJson) {
+  const opts = optionsJson ? JSON.parse(optionsJson) : {};
+  const {
+    cwd: cwdRaw = null,
+    timeout: timeoutRaw = null,
+    env: extraEnv = null,
+    background = false,
+  } = opts;
+
+  // Resolve working directory
+  let cwd = process.cwd();
+  if (cwdRaw) {
+    const resolved = resolve(cwdRaw);
+    if (!existsSync(resolved)) {
+      return `Error: Working directory not found: ${cwdRaw}`;
+    }
+    cwd = resolved;
+  }
+
+  // ── Filesystem scope enforcement ───────────────────────────────────────────
+  const allowedPaths = config.filesystem?.allowedPaths || [];
+  if (allowedPaths.length > 0) {
+    // Always check that the cwd is inside an allowed directory
+    const cwdGuard = filesystemGuard.checkRead(cwd);
+    if (!cwdGuard.allowed) {
+      return `Access denied: Working directory "${cwd}" is outside the allowed paths. ` +
+        `Allowed: ${allowedPaths.join(", ")}`;
+    }
+
+    // When RESTRICT_COMMANDS=true, also scan command string for absolute path references
+    if (config.filesystem?.restrictCommands) {
+      // Extract absolute paths from the command (Unix + Windows style)
+      const absPathPattern = /(\/[^\s'";|&><$]+|[A-Za-z]:\\[^\s'";|&><$]+)/g;
+      const matches = [...cmd.matchAll(absPathPattern)].map((m) => m[1]);
+      for (const p of matches) {
+        const check = filesystemGuard.checkRead(p);
+        if (!check.allowed) {
+          return `Access denied: Command references a path outside allowed directories: "${p}". ` +
+            `Allowed: ${allowedPaths.join(", ")}`;
+        }
+      }
+    }
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+
+  // Clamp timeout
+  const timeout = timeoutRaw
+    ? Math.min(parseInt(timeoutRaw), MAX_TIMEOUT_MS)
+    : DEFAULT_TIMEOUT_MS;
+
+  // Merge env
+  const env = extraEnv ? { ...process.env, ...extraEnv } : process.env;
+
+  console.log(`      [executeCommand] Running: ${cmd}${cwdRaw ? ` (cwd: ${cwdRaw})` : ""}${background ? " [background]" : ""}`);
+
+  // Background mode — spawn detached, return PID immediately
+  if (background) {
+    try {
+      const child = spawn("sh", ["-c", cmd], {
+        cwd,
+        env,
+        detached: true,
+        stdio: "ignore",
+      });
+      child.unref();
+      return `Background process started (PID: ${child.pid}). Command: ${cmd}`;
+    } catch (error) {
+      return `Error starting background process: ${error.message}`;
+    }
+  }
+
+  // Foreground mode — wait for result
+  try {
+    const result = execSync(cmd, {
+      encoding: "utf-8",
+      timeout,
+      maxBuffer: MAX_BUFFER,
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    console.log(`      [executeCommand] Done`);
+    return result.toString() || "(command completed with no output)";
+  } catch (error) {
+    if (error.killed) {
+      return `Command timed out after ${timeout / 1000}s. Try a shorter-running command or use background mode: {"background":true}`;
+    }
+
+    // Build a useful error message with stdout+stderr
+    const parts = [];
+    if (error.stdout) parts.push(`stdout:\n${error.stdout.slice(0, 2000)}`);
+    if (error.stderr) parts.push(`stderr:\n${error.stderr.slice(0, 2000)}`);
+    const exitMsg = error.status !== undefined ? ` (exit code: ${error.status})` : "";
+
+    if (parts.length > 0) {
+      return `Command failed${exitMsg}:\n${parts.join("\n---\n")}`;
+    }
+    return `Command failed${exitMsg}: ${error.message}`;
+  }
+}
+
+export const executeCommandDescription =
+  'executeCommand(cmd: string, optionsJson?: string) - Execute a shell command. optionsJson: {"cwd":"./src","timeout":30000,"env":{"NODE_ENV":"test"},"background":false}. timeout is in ms (max 600000). Use background:true for long-running processes (returns PID immediately).';

package/src/tools/glob.js

@@ -0,0 +1,67 @@
+/**
+ * glob(pattern, directory?) — Pattern-based file search with modification time sorting.
+ * Inspired by Claude Code's Glob tool and Gemini CLI's FindFiles.
+ */
+import { glob as globFn } from "glob";
+import { statSync } from "node:fs";
+import { resolve, relative } from "node:path";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+const TWENTY_FOUR_HOURS = 24 * 60 * 60 * 1000;
+
+export async function globSearch(pattern, directory) {
+  try {
+    const dir = directory ? resolve(directory) : process.cwd();
+
+    const guard = filesystemGuard.checkRead(dir);
+    if (!guard.allowed) return guard.reason;
+
+    const matches = await globFn(pattern, {
+      cwd: dir,
+      nodir: true,
+      dot: true,
+      ignore: ["**/node_modules/**", "**/.git/**"],
+      maxDepth: 20,
+    });
+
+    if (matches.length === 0) {
+      return `No files found matching "${pattern}" in ${dir}`;
+    }
+
+    // Stat files and sort: recently modified first, then alphabetical
+    const now = Date.now();
+    const filesWithStats = matches.map((file) => {
+      const fullPath = resolve(dir, file);
+      try {
+        const stat = statSync(fullPath);
+        return { path: file, mtime: stat.mtimeMs, recent: now - stat.mtimeMs < TWENTY_FOUR_HOURS };
+      } catch {
+        return { path: file, mtime: 0, recent: false };
+      }
+    });
+
+    // Recent files first (sorted by mtime desc), then rest alphabetically
+    filesWithStats.sort((a, b) => {
+      if (a.recent && !b.recent) return -1;
+      if (!a.recent && b.recent) return 1;
+      if (a.recent && b.recent) return b.mtime - a.mtime;
+      return a.path.localeCompare(b.path);
+    });
+
+    // Cap at 200 results
+    const limited = filesWithStats.slice(0, 200);
+    const lines = limited.map((f) => f.path);
+
+    let result = `Found ${matches.length} file(s) matching "${pattern}":\n`;
+    result += lines.join("\n");
+    if (matches.length > 200) {
+      result += `\n\n... and ${matches.length - 200} more files (showing first 200)`;
+    }
+    return result;
+  } catch (error) {
+    return `Error searching for "${pattern}": ${error.message}`;
+  }
+}
+
+export const globSearchDescription =
+  'globSearch(pattern: string, directory?: string) - Find files matching a glob pattern (e.g., "**/*.js", "src/**/*.ts"). Returns files sorted by modification time (recent first).';

package/src/tools/grep.js

@@ -0,0 +1,121 @@
+/**
+ * grep(pattern, optionsJson?) — Advanced content search with context lines.
+ * Inspired by Claude Code's Grep tool. Pure Node.js — no shell dependency.
+ */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, extname, relative } from "node:path";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+const EXCLUDED_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".cache"]);
+
+function walkDir(dir, fileType, results = []) {
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!EXCLUDED_DIRS.has(entry.name)) {
+          walkDir(join(dir, entry.name), fileType, results);
+        }
+      } else if (entry.isFile()) {
+        if (!fileType || extname(entry.name) === `.${fileType}` || entry.name.endsWith(`.${fileType}`)) {
+          results.push(join(dir, entry.name));
+        }
+      }
+    }
+  } catch {}
+  return results;
+}
+
+export function grep(pattern, optionsJson) {
+  try {
+    const opts = optionsJson ? JSON.parse(optionsJson) : {};
+    const {
+      directory = process.cwd(),
+      contextLines = 0,
+      caseInsensitive = false,
+      fileType = null,
+      outputMode = "content", // "content" | "files_only" | "count"
+      limit = 50,
+    } = opts;
+
+    const flags = caseInsensitive ? "gi" : "g";
+    const regex = new RegExp(pattern, flags);
+
+    const guard = filesystemGuard.checkRead(directory);
+    if (!guard.allowed) return guard.reason;
+
+    const files = walkDir(directory, fileType);
+    if (files.length === 0) {
+      return `No files found to search in ${directory}${fileType ? ` (type: ${fileType})` : ""}`;
+    }
+
+    const matchingFiles = [];
+    let totalMatches = 0;
+    const outputLines = [];
+
+    for (const file of files) {
+      let content;
+      try {
+        content = readFileSync(file, "utf-8");
+      } catch {
+        continue;
+      }
+
+      const lines = content.split("\n");
+      const fileMatches = [];
+
+      for (let i = 0; i < lines.length; i++) {
+        regex.lastIndex = 0;
+        if (regex.test(lines[i])) {
+          fileMatches.push(i);
+          totalMatches++;
+        }
+      }
+
+      if (fileMatches.length === 0) continue;
+
+      const relPath = relative(process.cwd(), file);
+      matchingFiles.push(relPath);
+
+      if (outputMode === "content" && outputLines.length < limit) {
+        for (const lineIdx of fileMatches) {
+          const start = Math.max(0, lineIdx - contextLines);
+          const end = Math.min(lines.length - 1, lineIdx + contextLines);
+
+          for (let j = start; j <= end; j++) {
+            const prefix = j === lineIdx ? `${relPath}:${j + 1}:` : `${relPath}-${j + 1}-`;
+            outputLines.push(`${prefix}${lines[j]}`);
+          }
+
+          if (contextLines > 0 && lineIdx !== fileMatches[fileMatches.length - 1]) {
+            outputLines.push("--");
+          }
+        }
+      }
+    }
+
+    if (matchingFiles.length === 0) {
+      return `No matches found for "${pattern}"`;
+    }
+
+    if (outputMode === "files_only") {
+      return `Files containing "${pattern}" (${matchingFiles.length}):\n${matchingFiles.join("\n")}`;
+    }
+
+    if (outputMode === "count") {
+      return `"${pattern}" found ${totalMatches} time(s) in ${matchingFiles.length} file(s)`;
+    }
+
+    // content mode
+    let result = outputLines.join("\n");
+    if (totalMatches > limit) {
+      result += `\n\n... showing first ${limit} matches of ${totalMatches} total`;
+    }
+    return result;
+  } catch (error) {
+    return `Error: ${error.message}`;
+  }
+}
+
+export const grepDescription =
+  'grep(pattern: string, optionsJson?: string) - Search file contents with regex. optionsJson: {"directory":"./src","contextLines":2,"caseInsensitive":true,"fileType":"js","outputMode":"content|files_only|count","limit":50}';

package/src/tools/imageAnalysis.js

@@ -0,0 +1,120 @@
+/**
+ * imageAnalysis(imagePath, prompt?) — Analyze images using vision AI models.
+ * Supports local files, URLs, and data: URIs.
+ * Uses the Vercel AI SDK with whatever vision-capable model is configured.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { extname } from "node:path";
+import { generateText } from "ai";
+import { getModelWithFallback } from "../models/ModelRouter.js";
+
+const MIME_MAP = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".bmp": "image/bmp",
+};
+
+// Vision-capable models to prefer (in order)
+const VISION_MODEL_PREFERENCE = [
+  "google:gemini-2.0-flash",
+  "openai:gpt-4.1",
+  "openai:gpt-4.1-mini",
+  "anthropic:claude-sonnet-4-6",
+];
+
+export async function imageAnalysis(imagePath, prompt) {
+  try {
+    const description = prompt || "Describe this image in detail. Include all visible text, UI elements, code, diagrams, or any other relevant content.";
+
+    let imageData;
+    let mimeType;
+
+    if (!imagePath) {
+      return "Error: imagePath is required";
+    }
+
+    if (imagePath.startsWith("data:")) {
+      // data: URI — extract base64 and mime type
+      const match = imagePath.match(/^data:([^;]+);base64,(.+)$/);
+      if (!match) return "Error: Invalid data: URI format";
+      mimeType = match[1];
+      imageData = match[2];
+    } else if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+      // URL — fetch and convert to base64
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 15000);
+      try {
+        const res = await fetch(imagePath, {
+          signal: controller.signal,
+          headers: { "User-Agent": "Daemora/1.0" },
+        });
+        clearTimeout(timeout);
+        if (!res.ok) return `Error fetching image: HTTP ${res.status}`;
+        const contentType = res.headers.get("content-type") || "image/jpeg";
+        mimeType = contentType.split(";")[0].trim();
+        const buffer = await res.arrayBuffer();
+        imageData = Buffer.from(buffer).toString("base64");
+      } catch (err) {
+        clearTimeout(timeout);
+        return `Error fetching image URL: ${err.message}`;
+      }
+    } else {
+      // Local file
+      if (!existsSync(imagePath)) {
+        return `Error: File not found: ${imagePath}`;
+      }
+      const ext = extname(imagePath).toLowerCase();
+      mimeType = MIME_MAP[ext];
+      if (!mimeType) {
+        return `Error: Unsupported image type: ${ext}. Supported: ${Object.keys(MIME_MAP).join(", ")}`;
+      }
+      const buffer = readFileSync(imagePath);
+      imageData = buffer.toString("base64");
+    }
+
+    // Try to get a vision-capable model
+    let selectedModel = null;
+    for (const modelId of VISION_MODEL_PREFERENCE) {
+      try {
+        const { model } = getModelWithFallback(modelId);
+        if (model) { selectedModel = model; break; }
+      } catch {}
+    }
+    if (!selectedModel) {
+      const { model } = getModelWithFallback(null);
+      selectedModel = model;
+    }
+
+    const response = await generateText({
+      model: selectedModel,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              image: imageData,
+              mimeType,
+            },
+            {
+              type: "text",
+              text: description,
+            },
+          ],
+        },
+      ],
+      maxTokens: 2048,
+    });
+
+    return response.text || "No analysis returned from model.";
+  } catch (error) {
+    return `Error analyzing image: ${error.message}`;
+  }
+}
+
+export const imageAnalysisDescription =
+  'imageAnalysis(imagePath: string, prompt?: string) - Analyze an image using AI vision. imagePath can be a local file path, URL, or data: URI. prompt is optional (defaults to "describe this image").';