patchwork-os 0.2.0-alpha.9 → 0.2.0-beta.1

package/dist/recipes/yamlRunner.d.ts

@@ -20,6 +20,9 @@
  *   manual, cron — both run immediately via CLI
  *   git_hook, on_file_save — also runnable manually; trigger context injected
  */
+import type { RecipeRunLog } from "../runLog.js";
+import type { ErrorPolicy } from "./schema.js";
+import "./tools/index.js";
 export interface YamlStep {
     tool?: string;
     agent?: {
@@ -27,9 +30,31 @@ export interface YamlStep {
         model?: string;
         into?: string;
         driver?: string;
+        /**
+         * Opt-in: inject bridge MCP tools (getAnalyticsReport, ctxQueryTraces, etc.)
+         * into the spawned `claude -p` subprocess via `--mcp-config`. Default off.
+         * Only honored by the subprocess driver path. Recursion risk: the subprocess
+         * could itself call `runClaudeTask` and chain into another bridge spawn —
+         * keep this off unless the prompt is read-only (telemetry summaries,
+         * trace queries, etc.).
+         */
+        mcpAccess?: boolean;
     };
     into?: string;
     optional?: boolean;
+    /** Retry count for this step on failure (overrides recipe-level on_error.retry). */
+    retry?: number;
+    /** Delay in ms between retries (default 1000). */
+    retryDelay?: number;
+    transform?: string;
+    /**
+     * Disable silent-fail detection for this step. Default `true` (detection
+     * ON) — runner flags steps whose output matches known placeholder patterns
+     * (`(git branches unavailable)`, `[agent step skipped: ...]`,
+     * `{count:0,error:"…"}`, etc.) as `error`. Set to `false` if your tool
+     * legitimately returns one of those shapes as a successful result.
+     */
+    silentFailDetection?: boolean;
     [key: string]: unknown;
 }
 export interface YamlTrigger {
@@ -39,14 +64,31 @@ export interface YamlTrigger {
     on?: string;
     filter?: string;
 }
+export interface YamlRecipeExpect {
+    stepsRun?: number;
+    outputs?: string[];
+    errorMessage?: string | null;
+    context?: Record<string, string>;
+}
+export interface AssertionFailure {
+    assertion: string;
+    expected: unknown;
+    actual: unknown;
+    message: string;
+}
+export declare function evaluateExpect(result: Pick<RunResult, "stepsRun" | "outputs" | "context" | "errorMessage">, expect: YamlRecipeExpect): AssertionFailure[];
 export interface YamlRecipe {
     name: string;
     description?: string;
     trigger: YamlTrigger;
     steps: YamlStep[];
+    expect?: YamlRecipeExpect;
     output?: {
         path: string;
     };
+    /** Plugin specs (npm package name or local path) to load before running steps. */
+    servers?: string[];
+    on_error?: ErrorPolicy;
 }
 export type RunContext = Record<string, string>;
 export type FetchFn = (url: string, init?: {
@@ -55,6 +97,9 @@ export type FetchFn = (url: string, init?: {
     ok: boolean;
     json(): Promise<unknown>;
 }>;
+export interface MockToolConnector {
+    invoke<TOutput = unknown>(operation: string, input?: unknown): Promise<TOutput>;
+}
 export interface RunnerDeps {
     now?: () => Date;
     readFile?: (p: string) => string;
@@ -71,22 +116,105 @@ export interface RunnerDeps {
     fetchFn?: FetchFn;
     /** Optional token resolver for Gmail. Defaults to getValidAccessToken(). */
     getGmailToken?: () => Promise<string>;
+    /** Optional token resolver for Google Drive. Defaults to getValidAccessToken(). */
+    getDriveToken?: () => Promise<string>;
+    /** Override the ~/.patchwork dir used by RecipeRunLog. Useful for tests. */
+    logDir?: string;
+    /**
+     * Long-lived `RecipeRunLog` instance. When set, the runner uses
+     * `startRun` + `completeRun` so the dashboard sees the run as `"running"`
+     * while it's in flight. Bridge-driven recipes pass this; CLI runs don't
+     * (they fall back to constructing a local log + `appendDirect`).
+     */
+    runLog?: RecipeRunLog;
     /** Optional Anthropic API caller for agent steps. Defaults to fetch-based impl. */
     claudeFn?: (prompt: string, model: string) => Promise<string>;
     /** Optional Claude Code CLI caller for agent steps with driver: claude-code. */
-    claudeCodeFn?: (prompt: string) => Promise<string>;
+    claudeCodeFn?: (prompt: string, opts?: {
+        mcpAccess?: boolean;
+    }) => Promise<string>;
+    /** Optional local LLM caller (Ollama / LM Studio) for agent steps with driver: local or model: local. */
+    localFn?: (prompt: string, model: string) => Promise<string>;
+    /**
+     * Optional provider driver invoker for agent steps with driver: openai|grok|gemini.
+     * Dispatches to src/drivers/* under the hood. If not provided, the runner will
+     * lazily construct a driver via createDriver() from drivers/index.js.
+     */
+    providerDriverFn?: (driverName: "openai" | "grok" | "gemini", prompt: string, model: string | undefined) => Promise<string>;
+    /** Mock connector replays used by `patchwork recipe test`. */
+    mockConnectors?: Partial<Record<string, MockToolConnector>>;
+    /** Directory to store recorded connector fixtures for `patchwork recipe record`. */
+    recordFixturesDir?: string;
+    /** Suppress run logs / notifications for mocked recipe test execution. */
+    testMode?: boolean;
 }
 export interface RunResult {
     recipe: string;
     stepsRun: number;
     outputs: string[];
     context: RunContext;
+    stepResults: StepResult[];
+    errorMessage?: string;
+    assertionFailures?: AssertionFailure[];
 }
+export type StepResult = {
+    id: string;
+    tool?: string;
+    status: "ok" | "skipped" | "error";
+    error?: string;
+    /**
+     * Structured error code propagated from a thrown step error. Currently
+     * populated for `recipe_path_jail_escape` (G-security A-PR1) so tests
+     * and the dashboard can branch on err.code rather than message text
+     * (R2 M-4). Other codes may follow.
+     */
+    errorCode?: string;
+    durationMs: number;
+};
+export type StepDeps = Required<Omit<RunnerDeps, "now" | "logDir" | "recordFixturesDir" | "runLog">> & {
+    workdir: string;
+    logDir?: string;
+    recordFixturesDir?: string;
+    runLog?: RecipeRunLog;
+    testMode: boolean;
+};
 export declare function loadYamlRecipe(filePath: string): YamlRecipe;
 export declare function validateYamlRecipe(raw: unknown): YamlRecipe;
+/**
+ * Load plugin specs declared in `recipe.servers` and register their tools into
+ * the recipe tool registry. Errors per-spec are logged as warnings — never fatal.
+ */
+export declare function loadRecipeServers(specs: string[]): Promise<void>;
 export declare function runYamlRecipe(recipe: YamlRecipe, deps?: RunnerDeps, seedContext?: RunContext): Promise<RunResult>;
-/** Minimal `{{ expr }}` renderer — replaces against flat context map. */
+export declare function executeStep(step: YamlStep, ctx: RunContext, deps: StepDeps): Promise<string | null>;
+/** Minimal `{{ expr }}` renderer — flat keys and dot-notation paths. */
 export declare function render(template: string, ctx: RunContext): string;
+export declare function defaultGitLogSince(since: string, workdir?: string): string;
+export declare function defaultGitStaleBranches(days: number, workdir?: string): string;
+/**
+ * Build ExecutionDeps for ChainedRecipeRunner backed by the yamlRunner step
+ * handlers. This lets chained recipes use the same tool set (file.*, git.*,
+ * gmail.*, github.*, linear.*, diagnostics.*) as simple YAML recipes.
+ *
+ * Pass the result as `chainedDeps` when calling `dispatchRecipe` or
+ * `runChainedRecipe` so that `executeTool` is properly wired.
+ */
+export declare function buildChainedDeps(runnerDeps: RunnerDeps, claudeCodeFnOverride?: (prompt: string, opts?: {
+    mcpAccess?: boolean;
+}) => Promise<string>): import("./chainedRunner.js").ExecutionDeps;
+/**
+ * Dispatch a loaded recipe to the appropriate runner.
+ *
+ * Recipes with `trigger.type: "chained"` are routed to the ChainedRecipeRunner
+ * (parallel execution, template variables, nested recipes, dry-run).
+ * All other recipes use the existing synchronous yamlRunner path.
+ *
+ * `chainedDeps` is only required when the recipe is chained; omit for simple recipes.
+ */
+export declare function dispatchRecipe(recipe: YamlRecipe, deps: RunnerDeps & {
+    chainedDeps?: import("./chainedRunner.js").ExecutionDeps;
+    chainedOptions?: Partial<import("./chainedRunner.js").RunOptions>;
+}, seedContext?: RunContext): Promise<RunResult | import("./chainedRunner.js").ChainedRunResult>;
 /** List all YAML recipes in a directory. Returns names. */
 export declare function listYamlRecipes(recipesDir: string): Array<{
     name: string;