patchwarden 0.4.0

package/dist/tools/listTasks.js

@@ -0,0 +1,94 @@
+import { readdirSync, readFileSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { getTasksDir, getPlansDir, getConfig } from "../config.js";
+import { readTaskRuntime } from "../taskRuntime.js";
+import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
+export function listTasks(input) {
+    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 = [];
+    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/dist/tools/listWorkspace.d.ts

@@ -0,0 +1,10 @@
+export interface ListEntry {
+    name: string;
+    type: "file" | "directory";
+    size?: number;
+}
+export interface ListWorkspaceOutput {
+    path: string;
+    entries: ListEntry[];
+}
+export declare function listWorkspace(relativePath?: string): ListWorkspaceOutput;

package/dist/tools/listWorkspace.js

@@ -0,0 +1,54 @@
+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";
+const MAX_LIST_FILES = 200;
+export function listWorkspace(relativePath) {
+    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 = [];
+    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/dist/tools/readWorkspaceFile.d.ts

@@ -0,0 +1,8 @@
+export interface ReadWorkspaceFileOutput {
+    path: string;
+    content: string;
+    size: number;
+    redacted?: boolean;
+    redaction_categories?: string[];
+}
+export declare function readWorkspaceFile(relativePath: string): ReadWorkspaceFileOutput;

package/dist/tools/readWorkspaceFile.js

@@ -0,0 +1,26 @@
+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 function readWorkspaceFile(relativePath) {
+    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,
+    };
+}

package/dist/tools/registry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Shared tool registry for PatchWarden MCP server.
+ * Used by both stdio (index.ts) and HTTP (httpServer.ts) transports.
+ */
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { type ToolCatalogSnapshot } from "./toolCatalog.js";
+export interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export declare function getToolDefs(): ToolDef[];
+export declare function getToolCatalogSnapshot(): ToolCatalogSnapshot;
+export declare function handleToolCall(name: string, args: Record<string, unknown> | undefined): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function registerTools(server: Server): void;