daemora 1.0.0

package/src/tools/projectTracker.js

@@ -0,0 +1,259 @@
+import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { config } from "../config/default.js";
+import { v4 as uuidv4 } from "uuid";
+
+const WORKSPACES_DIR = join(config.dataDir, "workspaces");
+
+/**
+ * Project Tracker — SQLite-equivalent task/project tracking for the agent.
+ *
+ * The agent uses this to plan multi-step work, track what's done vs pending,
+ * and resume from where it left off if interrupted.
+ *
+ * Actions:
+ *   createProject  — create a project with optional initial task list
+ *   addTask        — add a task to an existing project
+ *   updateTask     — mark a task as in_progress / done / failed / skipped
+ *   getProject     — full status of one project (what's done, what's pending)
+ *   listProjects   — all projects with summary
+ *   deleteProject  — remove a completed/stale project
+ *
+ * Storage: data/projects/<id>.json  (JSON files, no external deps)
+ */
+
+const PROJECTS_DIR = join(config.dataDir, "projects");
+
+function ensureDir() {
+  if (!existsSync(PROJECTS_DIR)) mkdirSync(PROJECTS_DIR, { recursive: true });
+}
+
+function loadProject(projectId) {
+  const path = join(PROJECTS_DIR, `${projectId}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveProject(project) {
+  ensureDir();
+  project.updatedAt = new Date().toISOString();
+  writeFileSync(join(PROJECTS_DIR, `${project.id}.json`), JSON.stringify(project, null, 2));
+}
+
+const STATUS_ICON = {
+  pending:     "⬜",
+  in_progress: "🔄",
+  done:        "✅",
+  failed:      "❌",
+  skipped:     "⏭️",
+};
+
+const VALID_TASK_STATUSES = ["pending", "in_progress", "done", "failed", "skipped"];
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function projectTracker(action, paramsJson) {
+  ensureDir();
+
+  const params = paramsJson
+    ? (typeof paramsJson === "string" ? JSON.parse(paramsJson) : paramsJson)
+    : {};
+
+  switch (action) {
+
+    // ── Create project ───────────────────────────────────────────────────────
+    case "createProject": {
+      const { name, description = "", tasks = [] } = params;
+      if (!name) return "Error: name is required";
+
+      const projectId = uuidv4().slice(0, 8);
+      const workspace = join(WORKSPACES_DIR, projectId);
+      mkdirSync(workspace, { recursive: true });
+
+      const project = {
+        id: projectId,
+        name,
+        description,
+        workspace,
+        status: "in_progress",
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        tasks: tasks.map((t, i) => ({
+          id: `t${i + 1}`,
+          title: typeof t === "string" ? t : t.title,
+          description: typeof t === "string" ? "" : (t.description || ""),
+          status: "pending",
+          notes: "",
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        })),
+      };
+
+      saveProject(project);
+
+      const taskList = project.tasks.length > 0
+        ? project.tasks.map(t => `  ${STATUS_ICON.pending} [${t.id}] ${t.title}`).join("\n")
+        : "  (no tasks yet — use addTask to add them)";
+
+      return `Project created: ${project.id}\nName: ${name}${description ? `\nDescription: ${description}` : ""}\nWorkspace: ${workspace}\nTasks (${project.tasks.length}):\n${taskList}`;
+    }
+
+    // ── Add task ─────────────────────────────────────────────────────────────
+    case "addTask": {
+      const { projectId, title, description = "" } = params;
+      if (!projectId || !title) return "Error: projectId and title are required";
+
+      const project = loadProject(projectId);
+      if (!project) return `Error: Project "${projectId}" not found`;
+
+      const taskNum = project.tasks.length + 1;
+      const task = {
+        id: `t${taskNum}`,
+        title,
+        description,
+        status: "pending",
+        notes: "",
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      project.tasks.push(task);
+      saveProject(project);
+
+      return `Task added: ${STATUS_ICON.pending} [${task.id}] ${title}`;
+    }
+
+    // ── Update task ──────────────────────────────────────────────────────────
+    case "updateTask": {
+      const { projectId, taskId, status, notes = "" } = params;
+      if (!projectId || !taskId || !status) {
+        return "Error: projectId, taskId, and status are required";
+      }
+      if (!VALID_TASK_STATUSES.includes(status)) {
+        return `Error: status must be one of: ${VALID_TASK_STATUSES.join(", ")}`;
+      }
+
+      const project = loadProject(projectId);
+      if (!project) return `Error: Project "${projectId}" not found`;
+
+      const task = project.tasks.find(t => t.id === taskId);
+      if (!task) return `Error: Task "${taskId}" not found in project ${projectId}`;
+
+      const oldStatus = task.status;
+      task.status = status;
+      if (notes) task.notes = notes;
+      task.updatedAt = new Date().toISOString();
+
+      // Auto-close project when all tasks are in a final state
+      const allFinal = project.tasks.every(t => ["done", "failed", "skipped"].includes(t.status));
+      if (allFinal) {
+        const anyFailed = project.tasks.some(t => t.status === "failed");
+        project.status = anyFailed ? "partial" : "done";
+      }
+
+      saveProject(project);
+
+      const icon = STATUS_ICON[status] || "?";
+      const noteStr = notes ? ` | Notes: ${notes}` : "";
+      return `Task [${taskId}] "${task.title}": ${oldStatus} → ${status} ${icon}${noteStr}`;
+    }
+
+    // ── Get project ──────────────────────────────────────────────────────────
+    case "getProject": {
+      const { projectId } = params;
+      if (!projectId) return "Error: projectId is required";
+
+      const project = loadProject(projectId);
+      if (!project) return `Error: Project "${projectId}" not found`;
+
+      const done    = project.tasks.filter(t => t.status === "done").length;
+      const total   = project.tasks.length;
+      const pct     = total > 0 ? Math.round((done / total) * 100) : 0;
+      const pending = project.tasks.filter(t => t.status === "pending").length;
+      const active  = project.tasks.filter(t => t.status === "in_progress").length;
+
+      const taskLines = project.tasks.map(t => {
+        const icon  = STATUS_ICON[t.status] || "?";
+        const notes = t.notes ? ` ← ${t.notes}` : "";
+        const desc  = t.description ? `\n       ${t.description}` : "";
+        return `  ${icon} [${t.id}] ${t.title}${notes}${desc}`;
+      }).join("\n");
+
+      const summary = [
+        `Project: ${project.name} [${project.id}]`,
+        `Status: ${project.status} | Progress: ${done}/${total} done (${pct}%)`,
+        pending > 0 ? `Pending: ${pending} tasks` : "",
+        active  > 0 ? `In progress: ${active} tasks` : "",
+        project.description ? `Description: ${project.description}` : "",
+        "",
+        "Tasks:",
+        taskLines || "  (no tasks)",
+      ].filter(l => l !== null && l !== undefined).join("\n");
+
+      return summary;
+    }
+
+    // ── List all projects ────────────────────────────────────────────────────
+    case "listProjects": {
+      const files = readdirSync(PROJECTS_DIR).filter(f => f.endsWith(".json"));
+      if (files.length === 0) return "No projects found. Use createProject to start one.";
+
+      const projects = files
+        .map(f => {
+          try { return JSON.parse(readFileSync(join(PROJECTS_DIR, f), "utf-8")); }
+          catch { return null; }
+        })
+        .filter(Boolean);
+
+      projects.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+
+      const { status: filterStatus, limit = 20 } = params;
+      const filtered = filterStatus
+        ? projects.filter(p => p.status === filterStatus)
+        : projects;
+
+      if (filtered.length === 0) return `No projects with status "${filterStatus}".`;
+
+      return filtered.slice(0, limit).map(p => {
+        const done  = p.tasks.filter(t => t.status === "done").length;
+        const total = p.tasks.length;
+        const pct   = total > 0 ? Math.round((done / total) * 100) : 0;
+        const date  = p.updatedAt.slice(0, 10);
+        const icon  = p.status === "done" ? "✅" : p.status === "partial" ? "⚠️" : "🔄";
+        return `${icon} [${p.id}] ${p.name} | ${done}/${total} (${pct}%) | updated ${date}`;
+      }).join("\n");
+    }
+
+    // ── Delete project ───────────────────────────────────────────────────────
+    case "deleteProject": {
+      const { projectId } = params;
+      if (!projectId) return "Error: projectId is required";
+
+      const path = join(PROJECTS_DIR, `${projectId}.json`);
+      if (!existsSync(path)) return `Error: Project "${projectId}" not found`;
+
+      const project = loadProject(projectId);
+      unlinkSync(path);
+      return `Project "${project?.name || projectId}" deleted.`;
+    }
+
+    default:
+      return `Unknown action: "${action}". Valid actions: createProject, addTask, updateTask, getProject, listProjects, deleteProject`;
+  }
+}
+
+export const projectTrackerDescription =
+  `projectTracker(action: string, paramsJson?: string) - Track multi-step project progress. Use this to plan work, mark tasks done/failed, and check what's remaining.
+  Actions:
+    createProject  - {"name":"Todo App","description":"...","tasks":["Create HTML","Create CSS","Create JS"]}
+    addTask        - {"projectId":"abc123","title":"Add dark mode","description":"optional detail"}
+    updateTask     - {"projectId":"abc123","taskId":"t1","status":"done","notes":"Created index.html with 8 components"}
+    getProject     - {"projectId":"abc123"}   → shows all tasks with ✅⬜🔄❌ status
+    listProjects   - {} or {"status":"in_progress"} → summary of all projects
+    deleteProject  - {"projectId":"abc123"}
+  Task statuses: pending | in_progress | done | failed | skipped
+  BEST PRACTICE: Always createProject + list all tasks FIRST, then work through them updating status as you go.`;

package/src/tools/readFile.js

@@ -0,0 +1,52 @@
+import { readFileSync } from "node:fs";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+/**
+ * Read a file with optional offset and limit (like Claude Code).
+ *
+ * @param {string} filePath - Path to the file
+ * @param {string} [offsetStr] - Line number to start from (1-based), default "1"
+ * @param {string} [limitStr] - Max lines to return, default "2000"
+ */
+export function readFile(filePath, offsetStr, limitStr) {
+  const offset = offsetStr ? parseInt(offsetStr, 10) : 1;
+  const limit = limitStr ? parseInt(limitStr, 10) : 2000;
+
+  // Filesystem security check
+  const guard = filesystemGuard.checkRead(filePath);
+  if (!guard.allowed) {
+    console.log(`      [readFile] BLOCKED: ${guard.reason}`);
+    return guard.reason;
+  }
+
+  console.log(`      [readFile] Reading: ${filePath} (offset: ${offset}, limit: ${limit})`);
+
+  try {
+    const content = readFileSync(filePath, { encoding: "utf-8" });
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+
+    // Apply offset (1-based) and limit
+    const startIdx = Math.max(0, offset - 1);
+    const endIdx = Math.min(totalLines, startIdx + limit);
+    const selectedLines = lines.slice(startIdx, endIdx);
+
+    const numbered = selectedLines
+      .map((line, i) => `${startIdx + i + 1} | ${line}`)
+      .join("\n");
+
+    let result = numbered;
+    if (endIdx < totalLines) {
+      result += `\n\n[... ${totalLines - endIdx} more lines. Use offset=${endIdx + 1} to continue reading.]`;
+    }
+
+    console.log(`      [readFile] Done — showing lines ${startIdx + 1}-${endIdx} of ${totalLines}`);
+    return result;
+  } catch (error) {
+    console.log(`      [readFile] Failed: ${error.message}`);
+    return `Error reading file: ${error.message}`;
+  }
+}
+
+export const readFileDescription =
+  "readFile(filePath: string, offset?: string, limit?: string) - Reads a file with line numbers. Optional offset (start line, 1-based) and limit (max lines, default 2000). For large files, read in chunks.";

package/src/tools/screenCapture.js

@@ -0,0 +1,112 @@
+/**
+ * screenCapture(optionsJson?) — Take a screenshot or record a screen video.
+ *
+ * Modes:
+ *   screenshot (default) — single still image (PNG)
+ *   video                — screen recording (MP4), uses `duration` seconds (default 10)
+ *
+ * macOS: uses built-in `screencapture` command.
+ * Linux: screenshots via ImageMagick/gnome-screenshot/scrot; video via ffmpeg.
+ *
+ * Returns the path to the saved file. Chain with imageAnalysis for screenshots,
+ * or sendFile to deliver the result to the user.
+ */
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
+import { platform } from "node:os";
+import { join } from "node:path";
+
+export function screenCapture(optionsJson) {
+  try {
+    const opts = optionsJson ? JSON.parse(optionsJson) : {};
+    const outputDir = opts.outputDir || "/tmp";
+    const region    = opts.region;                   // { x, y, width, height } — screenshot only
+    const mode      = (opts.mode || "screenshot").toLowerCase();
+    const duration  = parseInt(opts.duration || "10", 10); // seconds — video only
+
+    if (!existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const os = platform();
+
+    // ── Screenshot mode ──────────────────────────────────────────────────────
+    if (mode === "screenshot") {
+      const outputPath = join(outputDir, `screenshot-${timestamp}.png`);
+
+      if (os === "darwin") {
+        if (region) {
+          const { x = 0, y = 0, width = 800, height = 600 } = region;
+          execSync(`screencapture -x -R ${x},${y},${width},${height} "${outputPath}"`, { timeout: 10000 });
+        } else {
+          execSync(`screencapture -x "${outputPath}"`, { timeout: 10000 });
+        }
+      } else if (os === "linux") {
+        const tools = [
+          `import -window root "${outputPath}"`,
+          `gnome-screenshot -f "${outputPath}"`,
+          `scrot "${outputPath}"`,
+          `xwd -root -silent | convert xwd:- "${outputPath}"`,
+        ];
+        let captured = false;
+        for (const cmd of tools) {
+          try { execSync(cmd, { timeout: 10000 }); captured = true; break; } catch {}
+        }
+        if (!captured) {
+          return "Error: No screenshot tool available. Install ImageMagick: sudo apt install imagemagick";
+        }
+      } else {
+        return `Error: screenCapture is not supported on ${os}. Supported: macOS (darwin), Linux.`;
+      }
+
+      if (!existsSync(outputPath)) {
+        return "Error: Screenshot command ran but no file was created.";
+      }
+      return `Screenshot saved to: ${outputPath}`;
+    }
+
+    // ── Video mode ────────────────────────────────────────────────────────────
+    if (mode === "video") {
+      if (duration < 1 || duration > 300) {
+        return "Error: duration must be between 1 and 300 seconds.";
+      }
+      const outputPath = join(outputDir, `video-${timestamp}.mp4`);
+      const timeoutMs  = (duration + 30) * 1000;
+
+      if (os === "darwin") {
+        // screencapture -V records video. Available macOS 10.15+.
+        execSync(`screencapture -V ${duration} "${outputPath}"`, { timeout: timeoutMs });
+      } else if (os === "linux") {
+        // Try ffmpeg first (most capable), then recordmydesktop
+        const ffmpegCmd = `ffmpeg -y -f x11grab -t ${duration} -i :0.0 -c:v libx264 -preset fast "${outputPath}" 2>/dev/null`;
+        const rmdCmd    = `recordmydesktop --no-sound --fps 15 -o "${outputPath}" & sleep ${duration} && kill %1`;
+
+        let recorded = false;
+        for (const cmd of [ffmpegCmd, rmdCmd]) {
+          try { execSync(cmd, { timeout: timeoutMs }); recorded = true; break; } catch {}
+        }
+        if (!recorded) {
+          return "Error: No video recording tool available. Install ffmpeg: sudo apt install ffmpeg";
+        }
+      } else {
+        return `Error: Video recording is not supported on ${os}.`;
+      }
+
+      if (!existsSync(outputPath)) {
+        return "Error: Video recording ran but no file was created.";
+      }
+      return `Video saved to: ${outputPath} (${duration}s)`;
+    }
+
+    return `Error: Unknown mode "${mode}". Use "screenshot" or "video".`;
+  } catch (error) {
+    return `Error in screenCapture: ${error.message}`;
+  }
+}
+
+export const screenCaptureDescription =
+  'screenCapture(optionsJson?) — Capture a screenshot or record a screen video. ' +
+  'optionsJson: {"mode":"screenshot"|"video","outputDir":"/tmp","duration":10,"region":{"x":0,"y":0,"width":800,"height":600}}. ' +
+  'mode defaults to "screenshot". duration (seconds) only applies to video mode. ' +
+  'Returns the file path. Chain with imageAnalysis to analyze screenshots, or sendFile to deliver to user.';

package/src/tools/searchContent.js

@@ -0,0 +1,76 @@
+/**
+ * searchContent(pattern, directory?, optionsJson?) — Search file contents.
+ * Upgraded: context lines, case-insensitive, file type filter, extended regex support.
+ */
+import { execSync } from "node:child_process";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+function escapeShellArg(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+
+export function searchContent(pattern, directory = ".", optionsJson) {
+  // Support old 3-arg API (pattern, directory, limitStr) and new optionsJson
+  let opts = {};
+  if (optionsJson && !isNaN(parseInt(optionsJson))) {
+    opts = { limit: parseInt(optionsJson) };
+  } else if (optionsJson) {
+    try { opts = JSON.parse(optionsJson); } catch {}
+  }
+
+  const limit = opts.limit || 50;
+  const caseInsensitive = opts.caseInsensitive || false;
+  const contextLines = opts.contextLines ? parseInt(opts.contextLines) : 0;
+  const fileType = opts.fileType; // e.g., "js", "ts", "py"
+  const useExtendedRegex = opts.regex || false;
+
+  const guard = filesystemGuard.checkRead(directory);
+  if (!guard.allowed) {
+    console.log(`      [searchContent] BLOCKED: ${guard.reason}`);
+    return guard.reason;
+  }
+  console.log(`      [searchContent] "${pattern}" in ${directory} (limit: ${limit})`);
+
+  try {
+    // Build grep command with flags
+    let flags = "-rn";
+    if (caseInsensitive) flags += "i";
+    if (useExtendedRegex) flags += "E";
+    if (contextLines > 0) flags += ` -C ${contextLines}`;
+
+    let includeFlag = "";
+    if (fileType) {
+      includeFlag = `--include=${escapeShellArg(`*.${fileType}`)}`;
+    }
+
+    const cmd = [
+      `grep ${flags}`,
+      escapeShellArg(pattern),
+      escapeShellArg(directory),
+      "--exclude-dir=node_modules",
+      "--exclude-dir=.git",
+      "--exclude-dir=dist",
+      "--exclude-dir=.next",
+      includeFlag,
+      "2>/dev/null",
+      `| head -${limit}`,
+    ].filter(Boolean).join(" ");
+
+    const output = execSync(cmd, { encoding: "utf-8", maxBuffer: 1024 * 1024 });
+    const trimmed = output.trim();
+    if (!trimmed) {
+      return `No matches found for "${pattern}" in ${directory}`;
+    }
+
+    const lines = trimmed.split("\n");
+    const suffix = lines.length >= limit ? ` (limit: ${limit}, may have more — increase with optionsJson {"limit":200})` : "";
+    console.log(`      [searchContent] Found ${lines.length} match(es)`);
+    return `Found ${lines.length} match(es) for "${pattern}"${suffix}:\n\n${trimmed}`;
+  } catch (error) {
+    if (error.status === 1) return `No matches found for "${pattern}" in ${directory}`;
+    return `Error searching content: ${error.message}`;
+  }
+}
+
+export const searchContentDescription =
+  'searchContent(pattern: string, directory?: string, optionsJson?: string) - Search file contents with grep. optionsJson: {"limit":50,"caseInsensitive":true,"contextLines":2,"fileType":"js","regex":true}. Returns matching lines with file:line format.';

package/src/tools/searchFiles.js

@@ -0,0 +1,75 @@
+/**
+ * searchFiles(pattern, directory?, optionsJson?) — Find files by name pattern.
+ * Upgraded: modification time sorting, depth control, size filters.
+ */
+import { execSync } from "node:child_process";
+import { statSync } from "node:fs";
+import filesystemGuard from "../safety/FilesystemGuard.js";
+
+function escapeShellArg(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+
+export function searchFiles(pattern, directory = ".", optionsJson) {
+  let opts = {};
+  if (optionsJson) {
+    try { opts = JSON.parse(optionsJson); } catch {}
+  }
+
+  const sortBy = opts.sortBy; // "modified" | undefined
+  const maxDepth = opts.maxDepth ? parseInt(opts.maxDepth) : null;
+  const minSize = opts.minSize; // e.g., "+10k"
+  const maxSize = opts.maxSize; // e.g., "-1m"
+
+  const guard = filesystemGuard.checkRead(directory);
+  if (!guard.allowed) {
+    console.log(`      [searchFiles] BLOCKED: ${guard.reason}`);
+    return guard.reason;
+  }
+  console.log(`      [searchFiles] Pattern: "${pattern}" in ${directory}`);
+
+  try {
+    const parts = [
+      `find ${escapeShellArg(directory)}`,
+      `-name ${escapeShellArg(pattern)}`,
+      maxDepth ? `-maxdepth ${maxDepth}` : "",
+      minSize ? `-size +${minSize}` : "",
+      maxSize ? `-size -${maxSize}` : "",
+      `-not -path "*/node_modules/*"`,
+      `-not -path "*/.git/*"`,
+      `-not -path "*/dist/*"`,
+      `2>/dev/null`,
+    ].filter(Boolean).join(" ");
+
+    const output = execSync(parts, { encoding: "utf-8", maxBuffer: 1024 * 1024 });
+    const trimmed = output.trim();
+    if (!trimmed) {
+      return `No files found matching "${pattern}" in ${directory}`;
+    }
+
+    let files = trimmed.split("\n").filter(Boolean);
+
+    // Sort by modification time if requested
+    if (sortBy === "modified") {
+      files = files
+        .map((f) => {
+          try {
+            return { path: f, mtime: statSync(f).mtimeMs };
+          } catch {
+            return { path: f, mtime: 0 };
+          }
+        })
+        .sort((a, b) => b.mtime - a.mtime)
+        .map((f) => f.path);
+    }
+
+    console.log(`      [searchFiles] Found ${files.length} file(s)`);
+    return `Found ${files.length} file(s) matching "${pattern}":\n\n${files.join("\n")}`;
+  } catch (error) {
+    if (!error.stdout?.trim()) return `No files found matching "${pattern}" in ${directory}`;
+    return `Error searching files: ${error.message}`;
+  }
+}
+
+export const searchFilesDescription =
+  'searchFiles(pattern: string, directory?: string, optionsJson?: string) - Find files by name (supports wildcards: *.js, *.ts). optionsJson: {"sortBy":"modified","maxDepth":3,"minSize":"10k","maxSize":"1m"}. Skips node_modules/.git/dist.';