patchwarden 0.6.4 → 1.5.0

package/dist/tools/taskLineage.d.ts

@@ -0,0 +1,91 @@
+export type TaskLoopStopReason = "success" | "max_iterations_reached" | "verification_failed" | "high_risk_blocked" | "user_confirmation_required" | "agent_timeout" | "policy_blocked" | "watcher_blocked" | "direct_profile_disabled" | "direct_verification_failed" | "direct_audit_failed";
+export interface TaskLineageDirectSession {
+    session_id: string;
+    status?: "passed" | "failed" | "skipped";
+    command_count?: number;
+    passed_commands?: number;
+    failed_commands?: number;
+    timed_out_commands?: number;
+    audit_decision?: "pass" | "warn" | "fail" | "not_run";
+    changed_files_total?: number;
+    next_action?: string;
+}
+export interface TaskLineageWorktree {
+    isolation_mode: "current_repo" | "worktree";
+    worktree_id?: string;
+    worktree_path?: string;
+    branch?: string;
+    requested_base_branch?: string;
+    cleanup: "keep" | "archive" | "delete_ignored_only";
+    status: "not_used" | "active" | "failed";
+    next_action: string;
+}
+export interface TaskLineageAgentRouting {
+    requested_agent: string | null;
+    selected_agent: string;
+    reason: string;
+    fallback: boolean;
+}
+export interface TaskLineageRound {
+    iteration: number;
+    task_id: string;
+    role: "main" | "fix_tests" | "cleanup";
+    status: string;
+    terminal: boolean;
+    verification_status: string;
+    audit_verdict: string;
+    fail_checks: string[];
+    warn_checks: string[];
+    next_action: string;
+}
+export interface TaskLineageRecord {
+    lineage_id: string;
+    goal: string;
+    repo_path: string;
+    created_at: string;
+    updated_at: string;
+    final_status: "accepted" | "needs_fix" | "blocked" | "failed";
+    stop_reason: TaskLoopStopReason;
+    next_action: string;
+    main_task: string | null;
+    fix_tasks: string[];
+    cleanup_tasks: string[];
+    direct_sessions: Array<string | TaskLineageDirectSession>;
+    rounds: TaskLineageRound[];
+    warnings: string[];
+    errors: string[];
+    worktree?: TaskLineageWorktree;
+    agent_routing?: TaskLineageAgentRouting;
+}
+export interface SafeTaskLineage {
+    lineage_id: string;
+    goal: string;
+    repo_path: string;
+    created_at: string;
+    updated_at: string;
+    final_status: TaskLineageRecord["final_status"];
+    stop_reason: TaskLoopStopReason;
+    next_action: string;
+    tasks: {
+        main: string | null;
+        fix: string[];
+        cleanup: string[];
+        direct_sessions: TaskLineageDirectSession[];
+    };
+    worktree: TaskLineageWorktree;
+    agent_routing: TaskLineageAgentRouting | null;
+    verification: {
+        latest_status: string;
+        passed: boolean;
+    };
+    rounds: TaskLineageRound[];
+    warnings: string[];
+    errors: string[];
+    truncated: boolean;
+}
+export declare function createLineageId(now?: Date): string;
+export declare function writeTaskLineage(record: TaskLineageRecord): SafeTaskLineage;
+export declare function getTaskLineage(lineageId: string, options?: {
+    max_items?: number;
+}): SafeTaskLineage;
+export declare function toSafeTaskLineage(record: TaskLineageRecord, maxItems?: number): SafeTaskLineage;

package/dist/tools/taskLineage.js

@@ -0,0 +1,175 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getConfig } from "../config.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { redactSensitiveValue } from "../security/contentRedaction.js";
+import { PatchWardenError } from "../errors.js";
+export function createLineageId(now = new Date()) {
+    const stamp = now.toISOString().replace(/[-:.TZ]/g, "").slice(0, 14);
+    return `lineage_${stamp}_${randomBytes(4).toString("hex")}`;
+}
+export function writeTaskLineage(record) {
+    const config = getConfig();
+    const lineageDir = resolve(config.workspaceRoot, ".patchwarden", "lineages", record.lineage_id);
+    mkdirSync(lineageDir, { recursive: true });
+    const safeRecord = redactSensitiveValue(record).value;
+    writeFileSync(join(lineageDir, "lineage.json"), JSON.stringify(safeRecord, null, 2) + "\n", "utf-8");
+    writeFileSync(join(lineageDir, "SUMMARY.md"), buildSummaryMarkdown(safeRecord), "utf-8");
+    return toSafeTaskLineage(safeRecord);
+}
+export function getTaskLineage(lineageId, options = {}) {
+    const maxItems = normalizeMaxItems(options.max_items);
+    if (!/^[A-Za-z0-9_-]+$/.test(lineageId)) {
+        throw new PatchWardenError("invalid_lineage_id", "lineage_id may contain only letters, numbers, underscores, and hyphens.", "Pass a lineage_id returned by run_task_loop.", true, { lineage_id: lineageId });
+    }
+    const config = getConfig();
+    const lineageFile = resolve(config.workspaceRoot, ".patchwarden", "lineages", lineageId, "lineage.json");
+    guardReadPath(lineageFile, config.workspaceRoot, ".patchwarden/lineages");
+    if (!existsSync(lineageFile)) {
+        throw new PatchWardenError("lineage_not_found", `Task lineage not found: "${lineageId}".`, "Pass a lineage_id returned by run_task_loop.", true, { lineage_id: lineageId });
+    }
+    const raw = readFileSync(lineageFile, "utf-8").replace(/^\uFEFF/, "");
+    const record = JSON.parse(raw);
+    return toSafeTaskLineage(redactSensitiveValue(record).value, maxItems);
+}
+export function toSafeTaskLineage(record, maxItems = 8) {
+    const rounds = record.rounds.slice(0, maxItems);
+    const latest = record.rounds[record.rounds.length - 1];
+    const directSessions = normalizeDirectSessions(record.direct_sessions);
+    return {
+        lineage_id: record.lineage_id,
+        goal: record.goal,
+        repo_path: record.repo_path,
+        created_at: record.created_at,
+        updated_at: record.updated_at,
+        final_status: record.final_status,
+        stop_reason: record.stop_reason,
+        next_action: record.next_action,
+        tasks: {
+            main: record.main_task,
+            fix: record.fix_tasks.slice(0, maxItems),
+            cleanup: record.cleanup_tasks.slice(0, maxItems),
+            direct_sessions: directSessions.slice(0, maxItems),
+        },
+        worktree: normalizeWorktree(record.worktree),
+        agent_routing: record.agent_routing ? {
+            requested_agent: record.agent_routing.requested_agent,
+            selected_agent: truncate(String(record.agent_routing.selected_agent), 120),
+            reason: truncate(String(record.agent_routing.reason), 240),
+            fallback: Boolean(record.agent_routing.fallback),
+        } : null,
+        verification: {
+            latest_status: latest?.verification_status || "not_available",
+            passed: latest?.verification_status === "passed",
+        },
+        rounds,
+        warnings: record.warnings.slice(0, maxItems).map((value) => truncate(value, 240)),
+        errors: record.errors.slice(0, maxItems).map((value) => truncate(value, 240)),
+        truncated: record.rounds.length > maxItems ||
+            record.fix_tasks.length > maxItems ||
+            record.cleanup_tasks.length > maxItems ||
+            directSessions.length > maxItems ||
+            record.warnings.length > maxItems ||
+            record.errors.length > maxItems,
+    };
+}
+function buildSummaryMarkdown(record) {
+    const rounds = record.rounds.map((round) => `- ${round.role} ${round.task_id}: ${round.status}, verification=${round.verification_status}, audit=${round.audit_verdict}`);
+    return [
+        "# PatchWarden Task Lineage",
+        "",
+        `- Lineage: ${record.lineage_id}`,
+        `- Goal: ${record.goal}`,
+        `- Repo: ${record.repo_path}`,
+        `- Final status: ${record.final_status}`,
+        `- Stop reason: ${record.stop_reason}`,
+        `- Next action: ${record.next_action}`,
+        `- Isolation: ${normalizeWorktree(record.worktree).isolation_mode}`,
+        `- Worktree: ${formatWorktree(record.worktree)}`,
+        `- Agent routing: ${formatAgentRouting(record.agent_routing)}`,
+        "",
+        "## Tasks",
+        `- Main: ${record.main_task || "none"}`,
+        `- Fix tasks: ${record.fix_tasks.length > 0 ? record.fix_tasks.join(", ") : "none"}`,
+        `- Cleanup tasks: ${record.cleanup_tasks.length > 0 ? record.cleanup_tasks.join(", ") : "none"}`,
+        `- Direct sessions: ${formatDirectSessions(record.direct_sessions)}`,
+        "",
+        "## Rounds",
+        ...(rounds.length > 0 ? rounds : ["- None."]),
+        "",
+    ].join("\n");
+}
+function normalizeWorktree(value) {
+    if (!value) {
+        return {
+            isolation_mode: "current_repo",
+            cleanup: "keep",
+            status: "not_used",
+            next_action: "none",
+        };
+    }
+    return {
+        isolation_mode: value.isolation_mode === "worktree" ? "worktree" : "current_repo",
+        worktree_id: value.worktree_id ? truncate(String(value.worktree_id), 120) : undefined,
+        worktree_path: value.worktree_path ? truncate(String(value.worktree_path), 260) : undefined,
+        branch: value.branch ? truncate(String(value.branch), 160) : undefined,
+        requested_base_branch: value.requested_base_branch ? truncate(String(value.requested_base_branch), 160) : undefined,
+        cleanup: value.cleanup,
+        status: value.status,
+        next_action: truncate(String(value.next_action || "review_worktree"), 240),
+    };
+}
+function formatWorktree(value) {
+    const worktree = normalizeWorktree(value);
+    if (worktree.isolation_mode !== "worktree")
+        return "not used";
+    const id = worktree.worktree_id || "unknown";
+    const status = worktree.status || "unknown";
+    const branch = worktree.branch ? ` branch=${worktree.branch}` : "";
+    return `${id} status=${status}${branch}`;
+}
+function formatAgentRouting(value) {
+    if (!value)
+        return "not recorded";
+    const requested = value.requested_agent ? ` requested=${value.requested_agent}` : "";
+    return `${value.selected_agent}${requested} reason=${truncate(value.reason, 160)}`;
+}
+function normalizeDirectSessions(value) {
+    return value.map((entry) => {
+        if (typeof entry === "string")
+            return { session_id: entry };
+        return {
+            session_id: String(entry.session_id || ""),
+            status: entry.status,
+            command_count: entry.command_count,
+            passed_commands: entry.passed_commands,
+            failed_commands: entry.failed_commands,
+            timed_out_commands: entry.timed_out_commands,
+            audit_decision: entry.audit_decision,
+            changed_files_total: entry.changed_files_total,
+            next_action: entry.next_action ? truncate(String(entry.next_action), 240) : undefined,
+        };
+    }).filter((entry) => entry.session_id !== "");
+}
+function formatDirectSessions(value) {
+    const sessions = normalizeDirectSessions(value);
+    if (sessions.length === 0)
+        return "none";
+    return sessions.map((entry) => {
+        const status = entry.status ? ` status=${entry.status}` : "";
+        const audit = entry.audit_decision ? ` audit=${entry.audit_decision}` : "";
+        return `${entry.session_id}${status}${audit}`;
+    }).join(", ");
+}
+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 truncate(value, maxChars) {
+    return value.length <= maxChars ? value : `${value.slice(0, maxChars)}...`;
+}

package/dist/tools/toolCatalog.d.ts

@@ -1,4 +1,4 @@
-export type ToolProfile = "full" | "chatgpt_core" | "chatgpt_direct";
+export type ToolProfile = "full" | "chatgpt_core" | "chatgpt_direct" | "chatgpt_search";
 export interface CatalogTool {
     name: string;
     description: string;
@@ -12,8 +12,9 @@ export interface ToolCatalogSnapshot {
     tool_names: string[];
     tool_manifest_sha256: string;
 }
-export declare const CHATGPT_CORE_TOOL_NAMES: readonly ["health_check", "list_agents", "list_workspace", "read_workspace_file", "save_plan", "create_task", "wait_for_task", "get_task_summary", "get_diff", "get_result", "get_result_json", "get_test_log", "get_task_status", "list_tasks", "cancel_task", "audit_task", "safe_status"];
-export declare const CHATGPT_DIRECT_TOOL_NAMES: readonly ["health_check", "list_workspace", "create_direct_session", "search_workspace", "read_workspace_file", "apply_patch", "run_verification", "finalize_direct_session", "audit_session", "sync_file"];
+export declare const CHATGPT_CORE_TOOL_NAMES: readonly ["health_check", "list_agents", "list_workspace", "read_workspace_file", "save_plan", "create_task", "run_task_loop", "recommend_agent_for_task", "get_task_lineage", "export_task_evidence_pack", "get_project_policy", "wait_for_task", "get_task_summary", "get_diff", "get_result", "get_result_json", "get_test_log", "get_task_status", "list_tasks", "cancel_task", "audit_task", "safe_status", "safe_result", "safe_audit", "safe_test_summary", "safe_diff_summary"];
+export declare const CHATGPT_DIRECT_TOOL_NAMES: readonly ["health_check", "list_workspace", "create_direct_session", "search_workspace", "read_workspace_file", "apply_patch", "run_verification", "run_direct_verification_bundle", "finalize_direct_session", "audit_session", "safe_direct_summary", "safe_finalize_direct_session", "safe_audit_direct_session", "sync_file"];
+export declare const CHATGPT_SEARCH_TOOL_NAMES: readonly ["health_check", "discover_tools", "explain_tool", "invoke_discovered_tool", "safe_status"];
 export declare function resolveToolProfile(configProfile?: string): ToolProfile;
 export declare function selectToolsForProfile<T extends CatalogTool>(tools: T[], profile: ToolProfile, enableDirectProfile?: boolean): T[];
 export declare function buildToolCatalogSnapshot(tools: CatalogTool[], profile: ToolProfile): ToolCatalogSnapshot;

package/dist/tools/toolCatalog.js

@@ -7,6 +7,11 @@ export const CHATGPT_CORE_TOOL_NAMES = [
     "read_workspace_file",
     "save_plan",
     "create_task",
+    "run_task_loop",
+    "recommend_agent_for_task",
+    "get_task_lineage",
+    "export_task_evidence_pack",
+    "get_project_policy",
     "wait_for_task",
     "get_task_summary",
     "get_diff",
@@ -18,6 +23,10 @@ export const CHATGPT_CORE_TOOL_NAMES = [
     "cancel_task",
     "audit_task",
     "safe_status",
+    "safe_result",
+    "safe_audit",
+    "safe_test_summary",
+    "safe_diff_summary",
 ];
 export const CHATGPT_DIRECT_TOOL_NAMES = [
     "health_check",
@@ -27,15 +36,26 @@ export const CHATGPT_DIRECT_TOOL_NAMES = [
     "read_workspace_file",
     "apply_patch",
     "run_verification",
+    "run_direct_verification_bundle",
     "finalize_direct_session",
     "audit_session",
+    "safe_direct_summary",
+    "safe_finalize_direct_session",
+    "safe_audit_direct_session",
     "sync_file",
 ];
+export const CHATGPT_SEARCH_TOOL_NAMES = [
+    "health_check",
+    "discover_tools",
+    "explain_tool",
+    "invoke_discovered_tool",
+    "safe_status",
+];
 let lastSnapshot = null;
 export function resolveToolProfile(configProfile) {
     const raw = (process.env.PATCHWARDEN_TOOL_PROFILE || configProfile || "full").trim();
-    if (raw !== "full" && raw !== "chatgpt_core" && raw !== "chatgpt_direct") {
-        throw new Error(`Invalid tool profile "${raw}". Expected "full", "chatgpt_core", or "chatgpt_direct".`);
+    if (raw !== "full" && raw !== "chatgpt_core" && raw !== "chatgpt_direct" && raw !== "chatgpt_search") {
+        throw new Error(`Invalid tool profile "${raw}". Expected "full", "chatgpt_core", "chatgpt_direct", or "chatgpt_search".`);
     }
     return raw;
 }
@@ -51,18 +71,26 @@ export function selectToolsForProfile(tools, profile, enableDirectProfile) {
             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];
+    if (profile === "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_direct tool profile requires missing tool "${name}".`);
+            return tool;
+        });
     }
-    return CHATGPT_DIRECT_TOOL_NAMES.map((name) => {
+    // chatgpt_search: compact profile, 5 tools all required, no degraded mode
+    return CHATGPT_SEARCH_TOOL_NAMES.map((name) => {
         const tool = byName.get(name);
         if (!tool)
-            throw new Error(`chatgpt_direct tool profile requires missing tool "${name}".`);
+            throw new Error(`chatgpt_search tool profile requires missing tool "${name}".`);
         return tool;
     });
 }

package/dist/tools/toolRegistry.d.ts

@@ -0,0 +1,61 @@
+/**
+ * v0.7.1: 统一工具注册表 — SafeToolSearch 只读发现层的基础。
+ *
+ * 为每个 MCP 工具补全元数据：风险等级、模式、标签、别名、中文意图词。
+ * schema digest 使用稳定字段顺序的 canonical JSON → sha256 计算，
+ * 用于检测工具 schema 漂移、release check 校验、discover_tools 返回。
+ */
+import type { ToolProfile } from "./toolCatalog.js";
+import type { ToolDef } from "./registry.js";
+export type ToolRisk = "readonly" | "workspace_read_sensitive" | "workspace_write" | "command" | "release" | "credential_sensitive";
+export declare const TOOL_RISK_RANK: Record<ToolRisk, number>;
+export type ToolMode = "delegate" | "direct" | "audit" | "release" | "diagnostic";
+export interface PatchWardenToolMeta {
+    name: string;
+    title: string;
+    summary: string;
+    description: string;
+    profiles: ToolProfile[];
+    modes: ToolMode[];
+    tags: string[];
+    aliases: string[];
+    risk: ToolRisk;
+    requiresConfirmation: boolean;
+    /** sha256 of canonical-JSON(inputSchema)，用于检测 schema 漂移 */
+    inputSchemaDigest: string;
+    relatedTools?: string[];
+    examples?: string[];
+}
+export declare const INTENT_TERMS: Record<string, string[]>;
+interface StaticToolMeta {
+    title: string;
+    summary: string;
+    profiles: ToolProfile[];
+    modes: ToolMode[];
+    tags: string[];
+    aliases: string[];
+    risk: ToolRisk;
+    requiresConfirmation: boolean;
+    relatedTools?: string[];
+    examples?: string[];
+}
+/**
+ * 稳定 JSON 序列化：按字段名排序，避免 key 顺序导致 digest 漂移。
+ */
+export declare function stableJsonStringify(value: unknown): string;
+/**
+ * 计算 inputSchema 的 sha256 digest。
+ * 返回格式："sha256:<hex>"
+ */
+export declare function computeSchemaDigest(inputSchema: unknown): string;
+/**
+ * 从 ToolDef[] 构建带元数据的完整工具注册表。
+ * 静态元数据来自 STATIC_TOOL_META，schema digest 动态计算。
+ * 未在 STATIC_TOOL_META 中注册的工具会被跳过（不报错，保持前向兼容）。
+ */
+export declare function buildToolRegistry(tools: ToolDef[]): PatchWardenToolMeta[];
+/**
+ * 获取单个工具的元数据（不含 schema digest，digest 需从 registry 获取）。
+ */
+export declare function getStaticToolMeta(name: string): StaticToolMeta | undefined;
+export {};