patchwarden 0.4.0

package/src/tools/listTasks.ts

@@ -0,0 +1,139 @@
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { getTasksDir, getPlansDir, getConfig } from "../config.js";
+import { guardPath } from "../security/pathGuard.js";
+import { readTaskRuntime } from "../taskRuntime.js";
+import type { TaskPhase, TaskStatus } from "./createTask.js";
+import {
+  derivePendingReason,
+  readWatcherStatus,
+  type PendingReason,
+  type WatcherState,
+  type WatcherStatusSnapshot,
+} from "../watcherStatus.js";
+
+export interface TaskEntry {
+  task_id: string;
+  plan_id: string;
+  title: string;
+  agent: string;
+  status: TaskStatus;
+  phase: TaskPhase;
+  created_at: string;
+  updated_at: string;
+  workspace_root: string;
+  repo_path: string;
+  resolved_repo_path: string;
+  test_command: string;
+  verify_commands: string[];
+  error: string | null;
+  last_heartbeat_at: string;
+  current_command: string | null;
+  timeout_seconds: number;
+  pending_reason: PendingReason;
+  watcher_status: WatcherState;
+}
+
+export interface ListTasksInput {
+  status?: string;
+  repo_path?: string;
+  active_only?: boolean;
+  limit?: number;
+}
+
+export interface ListTasksOutput {
+  tasks: TaskEntry[];
+  total: number;
+  returned: number;
+  watcher: WatcherStatusSnapshot;
+}
+
+export function listTasks(input?: ListTasksInput): ListTasksOutput {
+  const config = getConfig();
+  const tasksDir = getTasksDir(config);
+  const plansDir = getPlansDir(config);
+  const limit = input?.limit && input.limit > 0 ? Math.min(input.limit, 100) : 20;
+  const filterStatus = input?.status || null;
+  const filterRepo = input?.repo_path?.trim().replace(/\\/g, "/") || null;
+  const watcher = readWatcherStatus(config);
+
+  if (!existsSync(tasksDir)) {
+    return { tasks: [], total: 0, returned: 0, watcher };
+  }
+
+  const entries = readdirSync(tasksDir, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .sort((a, b) => {
+      // Sort by mtime descending (newest first)
+      try {
+        const sa = statSync(join(tasksDir, a.name, "status.json"));
+        const sb = statSync(join(tasksDir, b.name, "status.json"));
+        return sb.mtimeMs - sa.mtimeMs;
+      } catch {
+        return b.name.localeCompare(a.name);
+      }
+    });
+
+  const tasks: TaskEntry[] = [];
+  let totalMatched = 0;
+
+  for (const entry of entries) {
+    const taskId = entry.name;
+    const taskDir = join(tasksDir, taskId);
+    const statusFile = join(taskDir, "status.json");
+
+    if (!existsSync(statusFile)) continue;
+
+    try {
+      const data = JSON.parse(readFileSync(statusFile, "utf-8"));
+      const runtime = readTaskRuntime(taskDir);
+      if (filterStatus && data.status !== filterStatus) continue;
+      if (input?.active_only && data.status !== "pending" && data.status !== "running") continue;
+      const normalizedRepo = String(data.repo_path || ".").replace(/\\/g, "/");
+      const normalizedResolvedRepo = String(data.resolved_repo_path || "").replace(/\\/g, "/");
+      if (filterRepo && normalizedRepo !== filterRepo && normalizedResolvedRepo !== filterRepo) continue;
+      totalMatched++;
+      if (tasks.length >= limit) continue;
+
+      // Read plan title from plans directory (not task dir)
+      let title = `Plan: ${data.plan_id || "unknown"}`;
+      if (data.plan_id) {
+        const planFile = join(plansDir, data.plan_id, "plan.md");
+        if (existsSync(planFile)) {
+          try {
+            const planContent = readFileSync(planFile, "utf-8");
+            const titleMatch = planContent.match(/^#\s*(.+)/m);
+            if (titleMatch) title = titleMatch[1];
+          } catch { /* keep default */ }
+        }
+      }
+
+      const phase = runtime.phase || data.phase || "queued";
+      tasks.push({
+        task_id: taskId,
+        plan_id: data.plan_id || "",
+        title,
+        agent: data.agent || "",
+        status: data.status || "pending",
+        phase,
+        created_at: data.created_at || "",
+        updated_at: data.updated_at || "",
+        workspace_root: data.workspace_root || config.workspaceRoot,
+        repo_path: data.repo_path || ".",
+        resolved_repo_path: data.resolved_repo_path || data.repo_path || config.workspaceRoot,
+        test_command: data.test_command || "",
+        verify_commands: Array.isArray(data.verify_commands) ? data.verify_commands : [],
+        error: data.error || null,
+        last_heartbeat_at: runtime.last_heartbeat_at || data.last_heartbeat_at || data.updated_at || "",
+        current_command: runtime.current_command ?? data.current_command ?? null,
+        timeout_seconds: data.timeout_seconds || config.defaultTaskTimeoutSeconds,
+        pending_reason: derivePendingReason({ status: data.status, phase }, watcher),
+        watcher_status: watcher.status,
+      });
+    } catch {
+      // skip corrupted entries
+    }
+  }
+
+  return { tasks, total: totalMatched, returned: tasks.length, watcher };
+}

package/src/tools/listWorkspace.ts

@@ -0,0 +1,71 @@
+import { readdirSync, statSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { getConfig } from "../config.js";
+import { guardPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+
+export interface ListEntry {
+  name: string;
+  type: "file" | "directory";
+  size?: number;
+}
+
+export interface ListWorkspaceOutput {
+  path: string;
+  entries: ListEntry[];
+}
+
+const MAX_LIST_FILES = 200;
+
+export function listWorkspace(relativePath?: string): ListWorkspaceOutput {
+  const config = getConfig();
+  const targetPath = relativePath
+    ? resolve(config.workspaceRoot, relativePath)
+    : config.workspaceRoot;
+
+  const guarded = guardPath(targetPath, config.workspaceRoot);
+
+  if (!existsSync(guarded)) {
+    throw new Error(`Path not found: "${relativePath || "."}"`);
+  }
+
+  const stat = statSync(guarded);
+  if (!stat.isDirectory()) {
+    throw new Error(`Not a directory: "${relativePath || "."}"`);
+  }
+
+  const entries: ListEntry[] = [];
+  const raw = readdirSync(guarded);
+
+  for (const name of raw) {
+    // Skip hidden files and sensitive paths
+    const fullPath = resolve(guarded, name);
+    try {
+      guardSensitivePath(fullPath);
+    } catch {
+      continue; // skip sensitive files silently
+    }
+
+    try {
+      const s = statSync(fullPath);
+      entries.push({
+        name,
+        type: s.isDirectory() ? "directory" : "file",
+        size: s.isFile() ? s.size : undefined,
+      });
+    } catch {
+      // can't stat, skip
+    }
+
+    if (entries.length >= MAX_LIST_FILES) break;
+  }
+
+  return {
+    path: relativePath || ".",
+    entries: entries.sort((a, b) => {
+      // directories first, then alphabetically
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      return a.name.localeCompare(b.name);
+    }),
+  };
+}

package/src/tools/readWorkspaceFile.ts

@@ -0,0 +1,41 @@
+import { readFileSync, statSync } from "node:fs";
+import { getConfig } from "../config.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
+
+export interface ReadWorkspaceFileOutput {
+  path: string;
+  content: string;
+  size: number;
+  redacted?: boolean;
+  redaction_categories?: string[];
+}
+
+export function readWorkspaceFile(relativePath: string): ReadWorkspaceFileOutput {
+  const config = getConfig();
+
+  const safePath = guardReadPath(relativePath, config.workspaceRoot);
+  guardSensitivePath(safePath);
+
+  const stat = statSync(safePath);
+  if (stat.size > config.maxReadFileBytes) {
+    throw new Error(
+      `File is ${stat.size} bytes, exceeds max of ${config.maxReadFileBytes} bytes.`
+    );
+  }
+
+  // Only allow text-like files
+  if (stat.size > 5_000_000) {
+    throw new Error("File exceeds 5 MB size limit.");
+  }
+
+  const redaction = redactSensitiveContent(readFileSync(safePath, "utf-8"));
+  return {
+    path: safePath,
+    content: redaction.content,
+    size: stat.size,
+    redacted: redaction.redacted,
+    redaction_categories: redaction.redaction_categories,
+  };
+}