patchwarden 0.4.0 → 0.6.1

package/dist/tools/getTaskSummary.js

@@ -12,7 +12,7 @@ const TERMINAL_STATUSES = new Set([
     "failed_policy_violation",
     "canceled",
 ]);
-export function getTaskSummary(taskId) {
+export function getTaskSummary(taskId, options = {}) {
     const config = getConfig();
     const taskDir = resolve(getTasksDir(config), taskId);
     const statusFile = join(taskDir, "status.json");
@@ -23,7 +23,12 @@ export function getTaskSummary(taskId) {
     const result = resultRead.data;
     const verify = verifyRead.data;
     const terminal = TERMINAL_STATUSES.has(String(status.status));
-    const outOfScope = asArray(result.out_of_scope_changes ?? status.out_of_scope_changes);
+    // Phase 4: Use new_out_of_scope_changes (task-caused) for acceptance status.
+    // Pre-existing external dirty files that didn't change should NOT fail acceptance.
+    const outOfScope = asArray(result.new_out_of_scope_changes
+        ?? status.new_out_of_scope_changes
+        ?? result.out_of_scope_changes
+        ?? status.out_of_scope_changes);
     const verifyStatus = String(verify.status ?? result.verify_status ?? result.verify?.status ?? status.verify_status ?? "not_available");
     const errors = [status.error, ...asArray(result.errors), ...asArray(result.known_issues)]
         .filter((value) => typeof value === "string" && value.trim() !== "");
@@ -92,6 +97,10 @@ export function getTaskSummary(taskId) {
         ? Math.max(0, (Number.isFinite(finishedAt) ? finishedAt : Date.now()) - startedAt)
         : 0;
     const changedFiles = asArray(result.changed_files ?? status.changed_files);
+    const changedFilesRead = tryReadJson(join(taskDir, "changed-files.json"));
+    const artifactHygiene = asRecord(result.artifact_hygiene ?? changedFilesRead.data.artifact_hygiene ?? {
+        counts: status.artifact_hygiene_counts || {},
+    });
     const verifyCommands = asArray(verify.commands ?? result.verify_commands ?? result.verify?.commands);
     const testLogSummary = summarizeTestLog(join(taskDir, "test.log"));
     const verificationSummary = buildVerificationSummary(verifyStatus, verifyCommands, testLogSummary);
@@ -156,7 +165,11 @@ export function getTaskSummary(taskId) {
         watcher: status.watcher,
         pending_reason: status.pending_reason || null,
         execution_blocked: Boolean(status.execution_blocked),
+        artifact_hygiene: artifactHygiene,
     };
+    if ((options.view || "standard") === "compact") {
+        return buildCompactSummary(output, normalizeMaxItems(options.max_items));
+    }
     const safe = redactSensitiveValue(output);
     return {
         ...safe.value,
@@ -164,6 +177,67 @@ export function getTaskSummary(taskId) {
         redaction_categories: safe.redaction_categories,
     };
 }
+function buildCompactSummary(output, maxItems) {
+    const hygiene = asRecord(output.artifact_hygiene);
+    const groupNames = [
+        "source_changes",
+        "tracked_build_artifacts",
+        "ignored_untracked_artifacts",
+        "runtime_generated_files",
+        "suspicious_changes",
+    ];
+    const groups = Object.fromEntries(groupNames.map((name) => [name, asArray(hygiene[name]).slice(0, maxItems)]));
+    const truncated = groupNames.some((name) => asArray(hygiene[name]).length > maxItems);
+    // Phase 6: Read artifact_manifest.json for release artifact info
+    const taskDir = resolve(getTasksDir(getConfig()), String(output.task_id));
+    const manifestRead = tryReadJson(join(taskDir, "artifact_manifest.json"));
+    const manifest = asRecord(manifestRead.data);
+    const releaseArtifacts = asArray(manifest.artifacts);
+    const releaseArtifactPaths = releaseArtifacts.map((a) => String(a.path || "")).slice(0, maxItems);
+    const compact = {
+        view: "compact",
+        task_id: String(output.task_id),
+        status: String(output.status),
+        terminal: Boolean(output.terminal),
+        acceptance_status: output.acceptance_status,
+        phase: String(output.phase),
+        repo_path: String(output.repo_path),
+        changed_files_total: asArray(output.changed_files).length,
+        out_of_scope_changes_total: asArray(output.out_of_scope_changes).length,
+        artifact_hygiene: {
+            counts: asRecord(hygiene.counts),
+            ...groups,
+            max_items: maxItems,
+            truncated,
+        },
+        release_artifacts_count: releaseArtifacts.length,
+        release_artifact_paths: releaseArtifactPaths,
+        artifact_status: String(output.artifact_status || manifest.status || "collected"),
+        verification_summary: output.verification_summary,
+        summary: String(output.summary).slice(0, 1000),
+        warnings: asArray(output.warnings).slice(0, maxItems),
+        errors: asArray(output.errors).slice(0, maxItems),
+        failure_reason: output.failure_reason || null,
+        failed_command: output.failed_command || null,
+        suggested_next_action: String(output.suggested_next_action),
+        execution_blocked: Boolean(output.execution_blocked),
+        pending_reason: output.pending_reason || null,
+    };
+    const safe = redactSensitiveValue(compact);
+    return {
+        ...safe.value,
+        redacted: safe.redacted,
+        redaction_categories: safe.redaction_categories,
+    };
+}
+function normalizeMaxItems(value) {
+    if (value === undefined)
+        return 8;
+    if (!Number.isInteger(value) || value < 1 || value > 50) {
+        throw new Error("max_items must be an integer from 1 to 50.");
+    }
+    return value;
+}
 function tryReadJson(path) {
     if (!existsSync(path))
         return { data: {} };
@@ -177,6 +251,9 @@ function tryReadJson(path) {
 function asArray(value) {
     return Array.isArray(value) ? value : [];
 }
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
 function summarizeTestLog(path) {
     if (!existsSync(path))
         return "test.log missing";

package/dist/tools/healthCheck.d.ts

@@ -20,18 +20,6 @@ export declare function healthCheck(catalog?: ToolCatalogSnapshot, input?: Healt
             error: string | null;
         }[];
     } | undefined;
-    status: string;
-    server_version: string;
-    schema_epoch: string;
-    tool_profile: string;
-    tool_count: number | null;
-    tool_names: string[];
-    tool_manifest_sha256: string | null;
-    profile_consistent: boolean;
-    profile_errors: string[];
-    catalog_consistent: boolean;
-    mismatch_report: string[];
-    tunnel_catalog_comparison: string;
     connector_visibility: {
         status: string;
         verification: string;
@@ -43,6 +31,10 @@ export declare function healthCheck(catalog?: ToolCatalogSnapshot, input?: Healt
         uptime_seconds: number;
         checked_at: string;
     };
+    path_encoding: {
+        encoding: string;
+        warnings: string[];
+    };
     watcher: {
         supervisor: Record<string, unknown>;
         status: import("../watcherStatus.js").WatcherState;
@@ -54,6 +46,7 @@ export declare function healthCheck(catalog?: ToolCatalogSnapshot, input?: Healt
         instance_id: string | null;
         launcher_pid: number | null;
         reason: string | null;
+        activity: string | null;
     };
     workspace_root: {
         available: boolean;
@@ -76,4 +69,26 @@ export declare function healthCheck(catalog?: ToolCatalogSnapshot, input?: Healt
     agent_status: {
         [k: string]: string;
     };
+    direct_tool_count?: number | undefined;
+    status: string;
+    server_version: string;
+    schema_epoch: string;
+    tool_profile: string;
+    tool_count: number | null;
+    tool_names: string[];
+    tool_manifest_sha256: string | null;
+    profile_consistent: boolean;
+    profile_errors: string[];
+    catalog_consistent: boolean;
+    mismatch_report: string[];
+    tunnel_catalog_comparison: string;
+    direct_profile_enabled: boolean;
+    direct_sessions_dir: {
+        available: boolean;
+        path: string;
+        readable: boolean;
+        writable: boolean;
+        reason: string | null;
+    };
+    direct_session_ttl_seconds: number;
 };

package/dist/tools/healthCheck.js

@@ -1,11 +1,11 @@
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { getConfig, getTasksDir, resolveWorkspaceRoot } from "../config.js";
+import { getConfig, getTasksDir, getDirectSessionsDir, resolveWorkspaceRoot } from "../config.js";
 import { listAgents } from "./listAgents.js";
 import { redactSensitiveContent, redactSensitiveValue } from "../security/contentRedaction.js";
 import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../version.js";
-import { CHATGPT_CORE_TOOL_NAMES, resolveToolProfile } from "./toolCatalog.js";
+import { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES, resolveToolProfile } from "./toolCatalog.js";
 import { readWatcherStatus } from "../watcherStatus.js";
 import { listTasks } from "./listTasks.js";
 const SERVER_STARTED_AT = Date.now();
@@ -26,9 +26,19 @@ export function healthCheck(catalog, input = {}) {
     let profileConsistent = true;
     if (catalog) {
         const activeProfile = resolveToolProfile(config.toolProfile);
-        const expectedNames = activeProfile === "chatgpt_core"
-            ? [...CHATGPT_CORE_TOOL_NAMES]
-            : null; // full profile: all tools are accepted
+        let expectedNames = null;
+        if (activeProfile === "chatgpt_core") {
+            expectedNames = [...CHATGPT_CORE_TOOL_NAMES];
+        }
+        else if (activeProfile === "chatgpt_direct" && config.enableDirectProfile) {
+            expectedNames = [...CHATGPT_DIRECT_TOOL_NAMES];
+        }
+        else if (activeProfile === "chatgpt_direct" && !config.enableDirectProfile) {
+            // Degraded mode: only health_check should be exposed
+            expectedNames = ["health_check"];
+            profileErrors.push("Direct profile is disabled (enableDirectProfile=false). Only health_check is available. Set enableDirectProfile: true to enable Direct session tools.");
+            profileConsistent = false;
+        }
         if (expectedNames) {
             const catalogNames = new Set(catalog.tool_names);
             for (const name of expectedNames) {
@@ -65,6 +75,9 @@ export function healthCheck(catalog, input = {}) {
     const status = watcher.available && workspace.available && tasks.available && agentReady && catalogConsistent
         ? "healthy"
         : "degraded";
+    const directSessionsDir = getDirectSessionsDir(config);
+    const directSessions = directoryStatus(directSessionsDir, true, workspaceRoot);
+    const activeProfile = resolveToolProfile(config.toolProfile);
     return {
         status,
         server_version: catalog?.server_version || PATCHWARDEN_VERSION,
@@ -78,11 +91,15 @@ export function healthCheck(catalog, input = {}) {
         catalog_consistent: catalogConsistent,
         mismatch_report: mismatchReport,
         tunnel_catalog_comparison: tunnelCatalogComparison,
+        direct_profile_enabled: config.enableDirectProfile ?? false,
+        direct_sessions_dir: directSessions,
+        direct_session_ttl_seconds: config.directSessionTtlSeconds,
+        ...(activeProfile === "chatgpt_direct" ? { direct_tool_count: config.enableDirectProfile ? CHATGPT_DIRECT_TOOL_NAMES.length : 1 } : {}),
         connector_visibility: {
             status: "not_observable_server_side",
             verification: "Refresh or reconnect the Connector and verify tools/list from a new ChatGPT conversation.",
             refresh_steps: [
-                "1. Run Check-PatchWarden-Health.cmd to confirm tool_profile=chatgpt_core, tool_count=16, and catalog_consistent=true.",
+                "1. Run PatchWarden.cmd health to confirm the active profile, tool count, and catalog consistency.",
                 "2. In ChatGPT Platform, refresh or reconnect the Connector (do not reuse an old session).",
                 "3. Open a NEW ChatGPT conversation (old conversations retain their cached tool catalog).",
                 "4. Call health_check in the new conversation; verify tool_manifest_sha256 matches the local report.",
@@ -94,6 +111,7 @@ export function healthCheck(catalog, input = {}) {
             uptime_seconds: Math.round((Date.now() - SERVER_STARTED_AT) / 1000),
             checked_at: new Date().toISOString(),
         },
+        path_encoding: checkPathEncoding(),
         watcher,
         workspace_root: workspace,
         tasks_dir: tasks,
@@ -228,3 +246,23 @@ function readTunnelStatus() {
 function safeText(value, maxLength) {
     return typeof value === "string" ? value.replace(/[\r\n]+/g, " ").slice(0, maxLength) : "";
 }
+function checkPathEncoding() {
+    const warnings = [];
+    // Node.js always uses UTF-8 for fs operations, but on Windows the console
+    // codepage can cause display issues. We check if the environment is likely
+    // to cause problems with non-ASCII paths.
+    if (process.platform === "win32") {
+        // Check if the system locale uses a codepage that might not support UTF-8
+        const lang = process.env.LANG || process.env.LC_ALL || "";
+        const chcp = process.env.PATCHWARDEN_CHCP || "";
+        if (chcp && !chcp.includes("65001") && !chcp.includes("utf")) {
+            warnings.push(`Windows codepage "${chcp}" may cause display issues with non-ASCII paths. Consider setting codepage to 65001 (UTF-8).`);
+        }
+    }
+    // Verify that Node.js fs operations use UTF-8 by default
+    // This is always true in Node.js >= 18
+    return {
+        encoding: "utf-8",
+        warnings,
+    };
+}

package/dist/tools/readWorkspaceFile.d.ts

@@ -4,5 +4,11 @@ export interface ReadWorkspaceFileOutput {
     size: number;
     redacted?: boolean;
     redaction_categories?: string[];
+    relative_path?: string;
+    sha256?: string;
 }
-export declare function readWorkspaceFile(relativePath: string): ReadWorkspaceFileOutput;
+export interface ReadWorkspaceFileInput {
+    path: string;
+    session_id?: string;
+}
+export declare function readWorkspaceFile(input: string | ReadWorkspaceFileInput): ReadWorkspaceFileOutput;

package/dist/tools/readWorkspaceFile.js

@@ -1,10 +1,28 @@
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync, statSync, existsSync } from "node:fs";
+import { createHash } from "node:crypto";
 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) {
+import { PatchWardenError } from "../errors.js";
+import { readDirectSession } from "../direct/directSessionStore.js";
+import { guardDirectSessionActive, guardDirectReadPath, isBinaryFile, guardDirectFileSize } from "../direct/directGuards.js";
+import { resolveToolProfile } from "./toolCatalog.js";
+export function readWorkspaceFile(input) {
     const config = getConfig();
+    // Support both old string API and new object API
+    const relativePath = typeof input === "string" ? input : input.path;
+    const sessionId = typeof input === "string" ? undefined : input.session_id;
+    // Direct mode: session_id provided
+    if (sessionId) {
+        return readWorkspaceFileDirect(relativePath, sessionId);
+    }
+    // In chatgpt_direct profile, session_id is required
+    const profile = resolveToolProfile(config.toolProfile);
+    if (profile === "chatgpt_direct") {
+        throw new PatchWardenError("session_id_required", "session_id is required when using the chatgpt_direct profile.", "Provide a session_id from create_direct_session.", true, { operation: "read_workspace_file" });
+    }
+    // Compatibility mode: no session_id, original behavior
     const safePath = guardReadPath(relativePath, config.workspaceRoot);
     guardSensitivePath(safePath);
     const stat = statSync(safePath);
@@ -24,3 +42,31 @@ export function readWorkspaceFile(relativePath) {
         redaction_categories: redaction.redaction_categories,
     };
 }
+function readWorkspaceFileDirect(relativePath, sessionId) {
+    const config = getConfig();
+    const session = readDirectSession(sessionId);
+    guardDirectSessionActive(session);
+    // Resolve path within session's repo
+    const safePath = guardDirectReadPath(relativePath, session.resolved_repo_path, config.workspaceRoot);
+    if (!existsSync(safePath)) {
+        throw new PatchWardenError("file_not_found", `File "${relativePath}" not found in session repo.`, "Use search_workspace to find available files.", true, { path: relativePath, session_id: sessionId });
+    }
+    const stat = statSync(safePath);
+    guardDirectFileSize(stat.size);
+    // Block binary files
+    if (isBinaryFile(safePath)) {
+        throw new PatchWardenError("binary_file_blocked", `File "${relativePath}" appears to be a binary file.`, "Binary files cannot be read in Direct mode.", true, { path: relativePath });
+    }
+    const content = readFileSync(safePath, "utf-8");
+    const redaction = redactSensitiveContent(content);
+    const sha256 = createHash("sha256").update(content, "utf-8").digest("hex");
+    return {
+        path: safePath,
+        relative_path: relativePath,
+        content: redaction.content,
+        size: stat.size,
+        sha256,
+        redacted: redaction.redacted,
+        redaction_categories: redaction.redaction_categories,
+    };
+}