patchwork-os 0.2.0-alpha.3 → 0.2.0-alpha.31

package/dist/recipes/agentExecutor.js

@@ -0,0 +1,42 @@
+/**
+ * Unified agent dispatch. Superset of both:
+ *   - runYamlRecipe agent block  (yamlRunner.ts:378-475)
+ *   - chainedRunner.executeAgent (yamlRunner.ts:1030-1058)
+ *
+ * Drift fix: chainedRunner was missing driver:"local" and pwCfg.model==="local".
+ * CHANGELOG: chained users with model:local in ~/.patchwork/config now route to
+ * localFn (Ollama/LM Studio) instead of Anthropic API — opt-in behaviour change.
+ */
+const DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+export async function executeAgent(input, deps) {
+    const { prompt, driver, model } = input;
+    if (driver === "anthropic" || driver === "claude") {
+        return deps.anthropicFn(prompt, model ?? DEFAULT_MODEL);
+    }
+    if (driver === "openai" || driver === "grok" || driver === "gemini") {
+        return deps.providerDriverFn(driver, prompt, model);
+    }
+    if (driver === "subprocess" || driver === "claude-code") {
+        return deps.claudeCliFn(prompt);
+    }
+    if (driver === "local") {
+        return deps.localFn(prompt, model ?? DEFAULT_MODEL);
+    }
+    if (driver !== undefined) {
+        throw new Error(`Unknown driver: "${driver}"`);
+    }
+    // No driver — check pwCfg for local model preference (THE MISSING BRANCH).
+    const pwCfg = deps.loadPatchworkConfig();
+    if (pwCfg.model === "local") {
+        return deps.localFn(prompt, model ?? DEFAULT_MODEL);
+    }
+    // Auto-detect: prefer API key, otherwise probe for claude CLI.
+    if (process.env.ANTHROPIC_API_KEY) {
+        return deps.anthropicFn(prompt, model ?? DEFAULT_MODEL);
+    }
+    if (deps.probeClaudeCli()) {
+        return deps.claudeCliFn(prompt);
+    }
+    return deps.anthropicFn(prompt, model ?? DEFAULT_MODEL);
+}
+//# sourceMappingURL=agentExecutor.js.map

package/dist/recipes/agentExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentExecutor.js","sourceRoot":"","sources":["../../src/recipes/agentExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAwBH,MAAM,aAAa,GAAG,2BAA2B,CAAC;AAElD,MAAM,CAAC,KAAK,UAAU,YAAY,CAChC,KAAyB,EACzB,IAAuB;IAEvB,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAExC,IAAI,MAAM,KAAK,WAAW,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QAClD,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,IAAI,aAAa,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,QAAQ,EAAE,CAAC;QACpE,OAAO,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;IACD,IAAI,MAAM,KAAK,YAAY,IAAI,MAAM,KAAK,aAAa,EAAE,CAAC;QACxD,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,MAAM,KAAK,OAAO,EAAE,CAAC;QACvB,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,aAAa,CAAC,CAAC;IACtD,CAAC;IACD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,oBAAoB,MAAM,GAAG,CAAC,CAAC;IACjD,CAAC;IAED,2EAA2E;IAC3E,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IACzC,IAAI,KAAK,CAAC,KAAK,KAAK,OAAO,EAAE,CAAC;QAC5B,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,IAAI,aAAa,CAAC,CAAC;IACtD,CAAC;IAED,+DAA+D;IAC/D,IAAI,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,IAAI,aAAa,CAAC,CAAC;IAC1D,CAAC;IACD,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,KAAK,IAAI,aAAa,CAAC,CAAC;AAC1D,CAAC"}

package/dist/recipes/chainedRunner.d.ts

@@ -0,0 +1,140 @@
+/**
+ * ChainedRecipeRunner — executes recipes with:
+ *   - Parallel step execution (respecting dependencies)
+ *   - Template-based variable resolution
+ *   - Nested recipe calls
+ *   - Conditional step execution (when)
+ *   - Dry-run mode
+ */
+import type { NestedRecipeConfig } from "./nestedRecipeStep.js";
+import type { OutputRegistry } from "./outputRegistry.js";
+import type { ErrorPolicy } from "./schema.js";
+import type { TemplateContext, TemplateError } from "./templateEngine.js";
+export interface ChainedStep {
+    id: string;
+    tool?: string;
+    agent?: {
+        prompt: string;
+        model?: string;
+        driver?: string;
+    };
+    recipe?: NestedRecipeConfig["recipe"];
+    chain?: NestedRecipeConfig["recipe"];
+    /** Sugar: run these steps concurrently. Expanded to flat steps at runtime. */
+    parallel?: ChainedStep[];
+    vars?: Record<string, string>;
+    awaits?: string[];
+    when?: string;
+    output?: string;
+    risk?: "low" | "medium" | "high";
+    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;
+    [key: string]: unknown;
+}
+export interface ChainedRecipe {
+    name: string;
+    description?: string;
+    steps: ChainedStep[];
+    maxConcurrency?: number;
+    maxDepth?: number;
+    /** Plugin specs (npm package name or local path) to load before running steps. */
+    servers?: string[];
+    on_error?: ErrorPolicy;
+}
+export interface RunOptions {
+    env: Record<string, string | undefined>;
+    maxConcurrency: number;
+    maxDepth: number;
+    dryRun: boolean;
+    sourcePath?: string;
+    onStepStart?: (stepId: string) => void;
+    onStepComplete?: (stepId: string, error?: Error) => void;
+    /**
+     * Directory holding `runs.jsonl`. When set, top-level (depth 0) runs are
+     * appended so the dashboard Runs page shows chained recipes alongside
+     * yamlRunner runs. Omit in tests to avoid filesystem writes.
+     */
+    runLogDir?: string;
+}
+export interface StepExecutionContext {
+    registry: OutputRegistry;
+    step: ChainedStep;
+    options: RunOptions;
+    recipe: ChainedRecipe;
+    depth: number;
+}
+export type ToolExecutor = (tool: string, params: Record<string, unknown>) => Promise<unknown>;
+export type AgentExecutor = (prompt: string, model?: string, driver?: string) => Promise<string>;
+export interface ExecutionDeps {
+    executeTool: ToolExecutor;
+    executeAgent: AgentExecutor;
+    loadNestedRecipe: (name: string, parentSourcePath?: string) => Promise<{
+        recipe: ChainedRecipe;
+        sourcePath?: string;
+    } | null>;
+}
+/** Build template context from registry and env */
+export declare function buildTemplateContext(registry: OutputRegistry, env: Record<string, string | undefined>): TemplateContext;
+/** Resolve all template strings in a step */
+export declare function resolveStepTemplates(step: ChainedStep, context: TemplateContext): {
+    resolved: Record<string, unknown>;
+    conditionResult: boolean;
+    errors: TemplateError[];
+};
+/** Execute a single step */
+export declare function executeChainedStep(ctx: StepExecutionContext, deps: ExecutionDeps): Promise<{
+    success: boolean;
+    skipped?: boolean;
+    data?: unknown;
+    error?: string;
+}>;
+export interface ChainedStepRunResult {
+    success: boolean;
+    skipped?: boolean;
+    durationMs?: number;
+    error?: Error;
+}
+export interface ChainedRunResult {
+    success: boolean;
+    stepResults: Map<string, ChainedStepRunResult>;
+    summary: {
+        total: number;
+        succeeded: number;
+        failed: number;
+        skipped: number;
+    };
+    errorMessage?: string;
+    /** Step output data keyed by step id, stringified for expect: assertions. */
+    context: Record<string, string>;
+}
+/**
+ * Expand `parallel:` sugar into flat steps with auto-generated ids and
+ * correct `awaits` wiring so the existing dependency graph handles execution.
+ *
+ * A `parallel:` step is a group container — it has no id/tool/agent of its
+ * own. Each child in the group inherits the group's `awaits` and is assigned
+ * an id of `<groupId>_<index>`. Steps that previously awaited the group
+ * (determined by a post-pass) are rewritten to await all children instead.
+ *
+ * Expansion is recursive so nested `parallel:` blocks work too.
+ */
+export declare function expandParallelSteps(steps: ChainedStep[]): ChainedStep[];
+/** Main entry point: run a chained recipe */
+export declare function runChainedRecipe(recipe: ChainedRecipe, options: RunOptions, deps: ExecutionDeps, existingRegistry?: OutputRegistry, depth?: number): Promise<ChainedRunResult>;
+/** Generate execution plan for dry-run mode */
+export declare function generateExecutionPlan(recipe: ChainedRecipe): {
+    steps: Array<{
+        id: string;
+        type: "tool" | "agent" | "recipe";
+        dependencies: string[];
+        condition?: string;
+        risk: "low" | "medium" | "high";
+        optional?: boolean;
+    }>;
+    parallelGroups: string[][];
+    maxDepth: number;
+};