patchwarden 1.5.1 → 1.6.2

package/src/tools/listAgents.ts

@@ -1,54 +0,0 @@
-import { existsSync, statSync } from "node:fs";
-import { basename, delimiter, extname, isAbsolute, join } from "node:path";
-import { getConfig } from "../config.js";
-
-export interface AgentAvailability {
-  name: string;
-  configured: true;
-  available: boolean;
-  command: string;
-  reason: string | null;
-  checked_at: string;
-}
-
-export function listAgents(): { agents: AgentAvailability[]; total: number } {
-  const config = getConfig();
-  const checkedAt = new Date().toISOString();
-  const agents = Object.entries(config.agents)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([name, agent]) => {
-      const available = commandExists(agent.command);
-      return {
-        name,
-        configured: true as const,
-        available,
-        command: basename(agent.command),
-        reason: available ? null : "Configured executable was not found on disk or PATH.",
-        checked_at: checkedAt,
-      };
-    });
-  return { agents, total: agents.length };
-}
-
-function commandExists(command: string): boolean {
-  if (isAbsolute(command) || command.includes("/") || command.includes("\\")) {
-    return isFile(command);
-  }
-
-  const pathEntries = (process.env.PATH || "").split(delimiter).filter(Boolean);
-  const extensions = process.platform === "win32"
-    ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";")
-    : [""];
-  const candidates = extname(command)
-    ? pathEntries.map((entry) => join(entry, command))
-    : pathEntries.flatMap((entry) => extensions.map((extension) => join(entry, `${command}${extension}`)));
-  return candidates.some(isFile);
-}
-
-function isFile(path: string): boolean {
-  try {
-    return existsSync(path) && statSync(path).isFile();
-  } catch {
-    return false;
-  }
-}

package/src/tools/retryTask.ts

@@ -1,53 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { createTask } from "./createTask.js";
-
-export async function retryTask(taskId: string) {
-  const config = getConfig();
-  const tasksDir = getTasksDir(config);
-  const taskDir = join(tasksDir, taskId);
-  const statusFile = join(taskDir, "status.json");
-
-  guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
-
-  if (!existsSync(statusFile)) {
-    throw new Error(`Task not found: "${taskId}"`);
-  }
-
-  const data = JSON.parse(readFileSync(statusFile, "utf-8"));
-
-  if (!data.plan_id || !data.agent) {
-    throw new Error(`Task "${taskId}" is missing plan_id or agent. Cannot retry.`);
-  }
-
-  // Create a new task with the same parameters
-  const newTask = await createTask({
-    plan_id: data.plan_id,
-    agent: data.agent,
-    repo_path: data.repo_path,
-    test_command: data.test_command,
-    verify_commands: data.verify_commands,
-    timeout_seconds: data.timeout_seconds,
-  });
-
-  // Record retry relationship in the new task
-  const newStatusFile = join(newTask.path, "status.json");
-  const newData = JSON.parse(readFileSync(newStatusFile, "utf-8"));
-  newData.retry_of = taskId;
-  newData.retry_count = (data.retry_count || 0) + 1;
-  newData.plan_source = data.plan_source || "saved";
-  newData.template = data.template || null;
-  newData.change_policy = data.change_policy || "repo_scoped_changes";
-  writeFileSync(newStatusFile, JSON.stringify(newData, null, 2), "utf-8");
-
-  return {
-    original_task_id: taskId,
-    new_task_id: newTask.task_id,
-    plan_id: newTask.plan_id,
-    agent: newTask.agent,
-    status: newTask.status,
-    message: `New task created from retry of ${taskId}. Original task is unchanged.`,
-  };
-}

package/src/tools/syncFile.ts

@@ -1,122 +0,0 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { dirname, resolve, relative, isAbsolute } from "node:path";
-import { PatchWardenError } from "../errors.js";
-import { getConfig, type PatchWardenConfig } from "../config.js";
-import { guardDirectPath, guardDirectWritePath } from "../direct/directGuards.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import { computeFileSha256 } from "../direct/directPatch.js";
-
-export interface SyncFileResult {
-  source_path: string;
-  target_path: string;
-  before_target_sha256: string | null;
-  after_target_sha256: string;
-  source_sha256: string;
-  copied_bytes: number;
-  changed: boolean;
-}
-
-/**
- * Copy a file from source to target within the same session repo.
- * Both source and target must be inside the session's repo_path.
- */
-export function syncFile(
-  sessionId: string,
-  sourcePath: string,
-  targetPath: string,
-  options?: {
-    expected_source_sha256?: string;
-    expected_target_sha256?: string;
-  },
-  config?: PatchWardenConfig
-): SyncFileResult {
-  const cfg = config || getConfig();
-  const sessionsDir = resolve(cfg.workspaceRoot, cfg.directSessionsDir);
-
-  // Load session to get repo_path
-  const sessionFile = resolve(sessionsDir, sessionId, "session.json");
-  if (!existsSync(sessionFile)) {
-    throw new PatchWardenError(
-      "direct_session_not_found",
-      `Direct session "${sessionId}" not found.`,
-      "Create a direct session first using direct_start_session.",
-      true,
-      { session_id: sessionId }
-    );
-  }
-
-  const session = JSON.parse(readFileSync(sessionFile, "utf-8"));
-  const repoPath = resolve(session.repo_path);
-  const workspaceRoot = cfg.workspaceRoot;
-
-  // Guard source path — must be inside repo
-  const resolvedSource = guardDirectPath(sourcePath, repoPath, workspaceRoot);
-  guardSensitivePath(resolvedSource);
-
-  if (!existsSync(resolvedSource)) {
-    throw new PatchWardenError(
-      "source_file_not_found",
-      `Source file does not exist: "${sourcePath}".`,
-      "Ensure the source path is correct.",
-      true,
-      { source_path: sourcePath }
-    );
-  }
-
-  // Guard target path — must be inside repo, not in blocked dirs
-  const resolvedTarget = guardDirectWritePath(targetPath, repoPath, workspaceRoot);
-  guardSensitivePath(resolvedTarget);
-
-  // Verify source sha256 if provided
-  const sourceSha256 = computeFileSha256(resolvedSource);
-  if (options?.expected_source_sha256 && options.expected_source_sha256 !== sourceSha256) {
-    throw new PatchWardenError(
-      "source_hash_mismatch",
-      `Source file hash mismatch. Expected "${options.expected_source_sha256}" but got "${sourceSha256}".`,
-      "Re-read the source file to get the current sha256.",
-      true,
-      { expected_sha256: options.expected_source_sha256, actual_sha256: sourceSha256 }
-    );
-  }
-
-  // Get target sha256 before copy
-  let beforeTargetSha256: string | null = null;
-  if (existsSync(resolvedTarget)) {
-    beforeTargetSha256 = computeFileSha256(resolvedTarget);
-    // Verify target sha256 if provided
-    if (options?.expected_target_sha256 && options.expected_target_sha256 !== beforeTargetSha256) {
-      throw new PatchWardenError(
-        "target_hash_mismatch",
-        `Target file hash mismatch. Expected "${options.expected_target_sha256}" but got "${beforeTargetSha256}".`,
-        "Re-read the target file to get the current sha256.",
-        true,
-        { expected_sha256: options.expected_target_sha256, actual_sha256: beforeTargetSha256 }
-      );
-    }
-  }
-
-  // Read source content
-  const sourceContent = readFileSync(resolvedSource);
-  const copiedBytes = sourceContent.length;
-
-  // Create target directory if needed
-  mkdirSync(dirname(resolvedTarget), { recursive: true });
-
-  // Write to target
-  writeFileSync(resolvedTarget, sourceContent, "utf-8");
-
-  // Compute after hash
-  const afterTargetSha256 = computeFileSha256(resolvedTarget);
-  const changed = beforeTargetSha256 !== afterTargetSha256;
-
-  return {
-    source_path: sourcePath,
-    target_path: targetPath,
-    before_target_sha256: beforeTargetSha256,
-    after_target_sha256: afterTargetSha256,
-    source_sha256: sourceSha256,
-    copied_bytes: copiedBytes,
-    changed,
-  };
-}