patchwarden 0.4.0 → 0.6.1

package/src/tools/savePlan.ts

@@ -1,12 +1,14 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve, join } from "node:path";
+import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { resolve, join, relative } from "node:path";
 import { getPlansDir, getConfig } from "../config.js";
 import { guardPath } from "../security/pathGuard.js";
 import { guardPlanContent } from "../security/planGuard.js";
+import { PatchWardenError } from "../errors.js";
 
 export interface SavePlanInput {
   title: string;
   content: string;
+  plan_ref?: string;
 }
 
 export interface SavePlanOutput {
@@ -19,9 +21,57 @@ export function savePlan(input: SavePlanInput): SavePlanOutput {
   const config = getConfig();
   const plansDir = getPlansDir(config);
 
-  guardPlanContent(input.title, input.content);
+  let content = input.content || "";
+  let title = input.title || "";
 
-  const planId = `plan_${Date.now()}_${sanitizeTitle(input.title)}`;
+  if (input.plan_ref) {
+    // 收缩 #3: plan_ref 只能读取 .patchwarden/plans 内文件，禁止任意路径
+    // plan_ref is relative to plansDir, not workspaceRoot
+    const targetPath = resolve(plansDir, input.plan_ref);
+    // Guard: must stay inside workspace and inside plansDir
+    guardPath(targetPath, config.workspaceRoot, config.plansDir);
+    const relativeToPlans = relative(plansDir, targetPath);
+    if (relativeToPlans.startsWith("..")) {
+      throw new PatchWardenError(
+        "plan_ref_outside_plans_dir",
+        `plan_ref must point to a file inside .patchwarden/plans.`,
+        "Use a path relative to .patchwarden/plans/.",
+        true,
+        { plan_ref: input.plan_ref, resolved: targetPath }
+      );
+    }
+    if (!existsSync(targetPath)) {
+      throw new PatchWardenError(
+        "plan_ref_not_found",
+        `plan_ref file not found: "${input.plan_ref}".`,
+        "Place the plan file under .patchwarden/plans/ first, then reference it.",
+        true,
+        { plan_ref: input.plan_ref }
+      );
+    }
+    content = readFileSync(targetPath, "utf-8");
+    if (!title || title.trim() === "") {
+      title = "Plan from file";
+    }
+  } else {
+    // Without plan_ref, content is required
+    if (!content || content.trim() === "") {
+      throw new PatchWardenError(
+        "plan_content_required",
+        "save_plan requires content or plan_ref.",
+        "Pass content with the plan text, or use plan_ref to load a file from .patchwarden/plans."
+      );
+    }
+  }
+
+  // Default title when empty
+  if (!title || title.trim() === "") {
+    title = "Inline plan";
+  }
+
+  guardPlanContent(title, content);
+
+  const planId = `plan_${Date.now()}_${sanitizeTitle(title)}`;
   const planDir = resolve(plansDir, planId);
 
   // Guards: plan dir & file must stay inside workspace
@@ -29,13 +79,13 @@ export function savePlan(input: SavePlanInput): SavePlanOutput {
   mkdirSync(planDir, { recursive: true });
 
   const planFile = join(planDir, "plan.md");
-  const header = `# ${input.title}\n\n> Plan ID: ${planId}\n> Created: ${new Date().toISOString()}\n\n`;
-  writeFileSync(planFile, header + input.content, "utf-8");
+  const header = `# ${title}\n\n> Plan ID: ${planId}\n> Created: ${new Date().toISOString()}\n\n`;
+  writeFileSync(planFile, header + content, "utf-8");
 
   return {
     plan_id: planId,
     path: planFile,
-    title: input.title,
+    title: title,
   };
 }
 

package/src/tools/searchWorkspace.ts

@@ -0,0 +1,275 @@
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { relative, join, extname } from "node:path";
+import { getConfig } from "../config.js";
+import { PatchWardenError } from "../errors.js";
+import { isSensitivePath } from "../security/sensitiveGuard.js";
+import {
+  readDirectSession,
+  validateDirectSessionFreshness,
+} from "../direct/directSessionStore.js";
+import { guardDirectSessionActive } from "../direct/directGuards.js";
+
+// ── Types ──────────────────────────────────────────────────────────
+
+export interface SearchWorkspaceInput {
+  session_id: string;
+  query: string;
+  max_results?: number;
+  case_sensitive?: boolean;
+  max_preview_chars?: number;
+  include_globs?: string[];
+}
+
+export interface SearchMatch {
+  path: string;
+  line: number;
+  preview: string;
+}
+
+export interface SearchWorkspaceOutput {
+  results: SearchMatch[];
+  total_matches: number;
+  truncated: boolean;
+}
+
+// ── Constants ──────────────────────────────────────────────────────
+
+const SKIP_DIRECTORIES = new Set([
+  ".git",
+  ".patchwarden",
+  "node_modules",
+  "dist",
+  "release",
+  "coverage",
+  ".next",
+  ".turbo",
+]);
+
+const BINARY_EXTENSIONS = new Set([
+  ".exe",
+  ".dll",
+  ".so",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".pdf",
+  ".mp3",
+  ".mp4",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".bin",
+  ".dat",
+  ".class",
+  ".jar",
+  ".wasm",
+  ".node",
+]);
+
+// Safety valve: stop scanning after this many total matches to prevent
+// runaway searches in large repositories with very common terms.
+const MAX_TOTAL_MATCHES = 10_000;
+
+// ── Tool implementation ────────────────────────────────────────────
+
+export function searchWorkspace(
+  input: SearchWorkspaceInput
+): SearchWorkspaceOutput {
+  const config = getConfig();
+
+  // ── Validate session freshness ───────────────────────────────────
+
+  const validation = validateDirectSessionFreshness(input.session_id);
+  if (!validation.valid || !validation.session) {
+    throw new PatchWardenError(
+      validation.failure_reason || "session_invalid",
+      `Direct session "${input.session_id}" is not valid: ${validation.failure_reason}.`,
+      "Create a new direct session with create_direct_session.",
+      true,
+      {
+        session_id: input.session_id,
+        failure_reason: validation.failure_reason,
+        operation: "search_workspace",
+      }
+    );
+  }
+
+  const session = validation.session;
+  guardDirectSessionActive(session);
+
+  // ── Validate query ───────────────────────────────────────────────
+
+  if (!input.query || input.query.trim() === "") {
+    throw new PatchWardenError(
+      "invalid_input",
+      "query is required and must be a non-empty string.",
+      "Provide a search query to look for in file contents.",
+      true,
+      { operation: "search_workspace", session_id: input.session_id }
+    );
+  }
+
+  // ── Resolve parameters ───────────────────────────────────────────
+
+  const maxResults = input.max_results ?? 20;
+  const caseSensitive = input.case_sensitive ?? false;
+  const maxPreviewChars = input.max_preview_chars ?? 200;
+  const includeGlobs = input.include_globs;
+  const query = caseSensitive ? input.query : input.query.toLowerCase();
+
+  const repoPath = session.resolved_repo_path;
+
+  if (!existsSync(repoPath)) {
+    throw new PatchWardenError(
+      "repo_not_found",
+      `Session repo path "${repoPath}" no longer exists.`,
+      "Create a new direct session with create_direct_session.",
+      true,
+      {
+        session_id: input.session_id,
+        resolved_repo_path: repoPath,
+        operation: "search_workspace",
+      }
+    );
+  }
+
+  // ── Recursive search ─────────────────────────────────────────────
+
+  const results: SearchMatch[] = [];
+  let totalMatches = 0;
+  let truncated = false;
+
+  const visit = (directory: string): void => {
+    if (truncated && totalMatches >= MAX_TOTAL_MATCHES) return;
+
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (totalMatches >= MAX_TOTAL_MATCHES) {
+        truncated = true;
+        return;
+      }
+
+      // Skip blacklisted directories
+      if (entry.isDirectory() && SKIP_DIRECTORIES.has(entry.name)) {
+        continue;
+      }
+
+      const fullPath = join(directory, entry.name);
+      const relPath = relative(repoPath, fullPath).replace(/\\/g, "/");
+
+      if (entry.isDirectory()) {
+        visit(fullPath);
+        continue;
+      }
+
+      if (!entry.isFile()) continue;
+
+      // Skip sensitive files
+      if (isSensitivePath(relPath)) continue;
+
+      // Skip binary files by extension
+      const ext = extname(entry.name).toLowerCase();
+      if (BINARY_EXTENSIONS.has(ext)) continue;
+
+      // Apply include_globs filter
+      if (includeGlobs && includeGlobs.length > 0) {
+        if (!matchesAnyGlob(relPath, includeGlobs)) continue;
+      }
+
+      // Read file content and search line by line
+      let content: string;
+      try {
+        const fileStat = statSync(fullPath);
+        if (fileStat.size > config.directMaxFileBytes) continue;
+        content = readFileSync(fullPath, "utf-8");
+      } catch {
+        continue;
+      }
+
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        if (totalMatches >= MAX_TOTAL_MATCHES) {
+          truncated = true;
+          break;
+        }
+
+        const line = lines[i];
+        const haystack = caseSensitive ? line : line.toLowerCase();
+        if (haystack.includes(query)) {
+          totalMatches++;
+          if (results.length < maxResults) {
+            const preview =
+              line.length > maxPreviewChars
+                ? line.slice(0, maxPreviewChars)
+                : line;
+            results.push({
+              path: relPath,
+              line: i + 1,
+              preview,
+            });
+          } else {
+            truncated = true;
+          }
+        }
+      }
+    }
+  };
+
+  visit(repoPath);
+
+  return {
+    results,
+    total_matches: totalMatches,
+    truncated,
+  };
+}
+
+// ── Glob matching ──────────────────────────────────────────────────
+
+function matchesAnyGlob(filePath: string, globs: string[]): boolean {
+  for (const pattern of globs) {
+    if (matchGlob(filePath, pattern)) return true;
+  }
+  return false;
+}
+
+/**
+ * Simple glob matching: "*" matches any sequence of characters (including
+ * path separators), "?" matches a single character.
+ *
+ * Examples:
+ *   "*.ts"       matches "foo.ts", "src/bar.ts"
+ *   "src/*.ts"   matches "src/foo.ts", "src/sub/bar.ts"
+ *   "*.test.ts"  matches "foo.test.ts", "src/bar.test.ts"
+ */
+function matchGlob(filePath: string, pattern: string): boolean {
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  const regex = globToRegex(normalizedPattern);
+  return regex.test(filePath);
+}
+
+function globToRegex(pattern: string): RegExp {
+  let regexStr = "";
+  for (const char of pattern) {
+    if (char === "*") {
+      regexStr += ".*";
+    } else if (char === "?") {
+      regexStr += ".";
+    } else if (/[.+^${}()|[\]\\]/.test(char)) {
+      regexStr += "\\" + char;
+    } else {
+      regexStr += char;
+    }
+  }
+  return new RegExp("^" + regexStr + "$");
+}

package/src/tools/syncFile.ts

@@ -0,0 +1,122 @@
+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,
+  };
+}

package/src/tools/taskTemplates.ts

@@ -42,7 +42,8 @@ export function expandTaskTemplate(input: TaskTemplateInput): ExpandedTaskTempla
     `## Goal\n${goal}`,
     "## Safety boundaries",
     "- Work only inside the resolved repository path.",
-    "- Do not commit, push, publish, expose credentials, or modify unrelated files.",
+    "- Leave repository changes uncommitted for review; remote operations are outside this task.",
+    "- Keep credentials private and do not modify unrelated files.",
     "- Report exact files inspected or changed and any remaining uncertainty.",
   ];
 

package/src/tools/toolCatalog.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../version.js";
 
-export type ToolProfile = "full" | "chatgpt_core";
+export type ToolProfile = "full" | "chatgpt_core" | "chatgpt_direct";
 
 export interface CatalogTool {
   name: string;
@@ -35,24 +35,55 @@ export const CHATGPT_CORE_TOOL_NAMES = [
   "list_tasks",
   "cancel_task",
   "audit_task",
+  "safe_status",
+] as const;
+
+export const CHATGPT_DIRECT_TOOL_NAMES = [
+  "health_check",
+  "list_workspace",
+  "create_direct_session",
+  "search_workspace",
+  "read_workspace_file",
+  "apply_patch",
+  "run_verification",
+  "finalize_direct_session",
+  "audit_session",
+  "sync_file",
 ] as const;
 
 let lastSnapshot: ToolCatalogSnapshot | null = null;
 
 export function resolveToolProfile(configProfile?: string): ToolProfile {
   const raw = (process.env.PATCHWARDEN_TOOL_PROFILE || configProfile || "full").trim();
-  if (raw !== "full" && raw !== "chatgpt_core") {
-    throw new Error(`Invalid tool profile "${raw}". Expected "full" or "chatgpt_core".`);
+  if (raw !== "full" && raw !== "chatgpt_core" && raw !== "chatgpt_direct") {
+    throw new Error(`Invalid tool profile "${raw}". Expected "full", "chatgpt_core", or "chatgpt_direct".`);
   }
   return raw;
 }
 
-export function selectToolsForProfile<T extends CatalogTool>(tools: T[], profile: ToolProfile): T[] {
+export function selectToolsForProfile<T extends CatalogTool>(tools: T[], profile: ToolProfile, enableDirectProfile?: boolean): T[] {
   if (profile === "full") return tools;
   const byName = new Map(tools.map((tool) => [tool.name, tool]));
-  return CHATGPT_CORE_TOOL_NAMES.map((name) => {
+
+  if (profile === "chatgpt_core") {
+    return CHATGPT_CORE_TOOL_NAMES.map((name) => {
+      const tool = byName.get(name);
+      if (!tool) throw new Error(`chatgpt_core tool profile requires missing tool "${name}".`);
+      return tool;
+    });
+  }
+
+  // chatgpt_direct
+  if (!enableDirectProfile) {
+    // Degraded mode: only expose health_check for diagnostics
+    const tool = byName.get("health_check");
+    if (!tool) throw new Error(`chatgpt_direct degraded mode requires missing tool "health_check".`);
+    return [tool];
+  }
+
+  return CHATGPT_DIRECT_TOOL_NAMES.map((name) => {
     const tool = byName.get(name);
-    if (!tool) throw new Error(`chatgpt_core tool profile requires missing tool "${name}".`);
+    if (!tool) throw new Error(`chatgpt_direct tool profile requires missing tool "${name}".`);
     return tool;
   });
 }

package/src/tools/waitForTask.ts

@@ -1,6 +1,6 @@
 import { setTimeout as sleep } from "node:timers/promises";
 import { getTaskStatus } from "./getTaskStatus.js";
-import { getTaskSummary, type TaskSummaryOutput } from "./getTaskSummary.js";
+import { getTaskSummary, type TaskSummaryResult } from "./getTaskSummary.js";
 
 const TERMINAL_STATUSES = new Set([
   "done",
@@ -32,7 +32,7 @@ export interface WaitForTaskOutput {
     name: "wait_for_task" | "audit_task" | "health_check";
     arguments: Record<string, unknown>;
   };
-  summary?: TaskSummaryOutput;
+  summary?: TaskSummaryResult;
   progress_summary?: WaitForTaskProgressSummary;
 }
 
@@ -85,6 +85,6 @@ export async function waitForTask(taskId: string, waitSeconds = 25): Promise<Wai
       : executionBlocked
         ? { name: "health_check", arguments: {} }
       : { name: "wait_for_task", arguments: { task_id: taskId, timeout_seconds: waitSeconds } },
-    ...(terminal ? { summary: getTaskSummary(taskId) } : { progress_summary: progressSummary }),
+    ...(terminal ? { summary: getTaskSummary(taskId, { view: "compact" }) } : { progress_summary: progressSummary }),
   };
 }

package/src/version.ts

@@ -1,2 +1,2 @@
-export const PATCHWARDEN_VERSION = "0.4.0";
-export const TOOL_SCHEMA_EPOCH = "2026-06-21-v3";
+export const PATCHWARDEN_VERSION = "0.6.1";
+export const TOOL_SCHEMA_EPOCH = "2026-06-24-v7";