@qodo/sdk 0.13.4 → 2.0.0-next.0

package/dist/sdk/middleware.js

@@ -1,69 +0,0 @@
-/**
- * Public Tool Middleware API for SDK consumers.
- *
- * Middleware hooks run around tool execution, allowing consumers to inspect,
- * modify, or log tool calls and results without touching internal code.
- *
- * Safety guarantees:
- * - Protected fields (identifier, server_name, session_id) cannot be overwritten
- * - User middleware is wrapped in a configurable timeout (default 10 s)
- * - Errors in middleware are caught and reported, never crash the run
- */
-/** Default timeout for user-registered middleware hooks (ms). */
-export const MIDDLEWARE_TIMEOUT_MS = 10_000;
-/**
- * Fields on ToolData that middleware is NOT allowed to overwrite.
- * These are set by the engine and are essential for routing / identity.
- */
-export const PROTECTED_TOOL_FIELDS = new Set([
-    'identifier',
-    'server_name',
-    'session_id',
-]);
-/**
- * Error class for middleware failures.
- * Contains the middleware name and phase for diagnostics.
- */
-export class ToolMiddlewareError extends Error {
-    middlewareName;
-    phase;
-    cause;
-    constructor(message, middlewareName, phase, cause) {
-        super(message);
-        this.middlewareName = middlewareName;
-        this.phase = phase;
-        this.cause = cause;
-        this.name = 'ToolMiddlewareError';
-    }
-}
-/**
- * Strip protected fields from a partial ToolData override.
- */
-export function stripProtectedFields(partial) {
-    const cleaned = { ...partial };
-    for (const field of PROTECTED_TOOL_FIELDS) {
-        delete cleaned[field];
-    }
-    return cleaned;
-}
-/**
- * Wrap an async function with a timeout.
- * Rejects with ToolMiddlewareError if the timeout expires.
- */
-export function withTimeout(fn, timeoutMs, middlewareName, phase) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            reject(new ToolMiddlewareError(`Middleware "${middlewareName}" timed out after ${timeoutMs}ms in ${phase}`, middlewareName, phase));
-        }, timeoutMs);
-        Promise.resolve(fn())
-            .then((result) => {
-            clearTimeout(timer);
-            resolve(result);
-        })
-            .catch((err) => {
-            clearTimeout(timer);
-            reject(err);
-        });
-    });
-}
-//# sourceMappingURL=middleware.js.map

package/dist/sdk/middleware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../src/sdk/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,iEAAiE;AACjE,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAwB,IAAI,GAAG,CAAC;IAChE,YAAY;IACZ,aAAa;IACb,YAAY;CACb,CAAC,CAAC;AAyBH;;;GAGG;AACH,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAG1B;IACA;IACA;IAJlB,YACE,OAAe,EACC,cAAsB,EACtB,KAAmC,EACnC,KAAa;QAE7B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJC,mBAAc,GAAd,cAAc,CAAQ;QACtB,UAAK,GAAL,KAAK,CAA8B;QACnC,UAAK,GAAL,KAAK,CAAQ;QAG7B,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAA0B;IAC7D,MAAM,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,qBAAqB,EAAE,CAAC;QAC1C,OAAQ,OAAe,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CACzB,EAAwB,EACxB,SAAiB,EACjB,cAAsB,EACtB,KAAmC;IAEnC,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,CACJ,IAAI,mBAAmB,CACrB,eAAe,cAAc,qBAAqB,SAAS,SAAS,KAAK,EAAE,EAC3E,cAAc,EACd,KAAK,CACN,CACF,CAAC;QACJ,CAAC,EAAE,SAAS,CAAC,CAAC;QAEd,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC;aAClB,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YACf,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,OAAO,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC,CAAC;aACD,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;YACb,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAC,GAAG,CAAC,CAAC;QACd,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/sdk/pipeline/PipelineBuilder.d.ts

@@ -1,79 +0,0 @@
-/**
- * Fluent builder for constructing typed pipelines.
- *
- * Usage:
- *   const pipeline = sdkPipeline<{ repo: string }>()
- *     .step('lint', async ({ state, run }) => {
- *       const result = await run('lint', { args: { path: state.repo } });
- *       return { lintOutput: result.result.final_output };
- *     })
- *     .step('review', async ({ state, run }) => {
- *       const result = await run('review', { extraInstructions: state.lintOutput });
- *       return { reviewOutput: result.result.final_output };
- *     })
- *     .build();
- */
-import type { PipelineEntry, StepFn, GateFn, ErrorStrategy } from './types.js';
-export interface StepOptions<TState, TOut> {
-    /** Error recovery strategy (default: 'throw'). */
-    onError?: ErrorStrategy<TState, TOut>;
-}
-/**
- * Immutable pipeline builder that tracks accumulated state type TState.
- *
- * Each .step() call produces a new builder whose TState is the intersection
- * of the previous state and the step's output type. This gives full type
- * inference through the chain without explicit generics at each step.
- */
-export declare class PipelineBuilder<TState extends Record<string, any>, TInit extends Record<string, any> = TState> {
-    constructor(entries?: PipelineEntry<TState>[]);
-    /**
-     * Add a sequential step to the pipeline.
-     *
-     * The step function receives the accumulated state and must return an
-     * object whose keys are merged into the state for subsequent steps.
-     */
-    step<TOut extends Record<string, any>>(name: string, fn: StepFn<TState, TOut>, options?: StepOptions<TState, TOut>): PipelineBuilder<TState & TOut, TInit>;
-    /**
-     * Add a group of steps that execute in parallel.
-     *
-     * All steps in the group receive the same snapshot of state. Their
-     * outputs are merged (Object.assign order matches declaration order).
-     */
-    parallel<TOut extends Record<string, any>>(steps: Array<{
-        name: string;
-        fn: StepFn<TState, TOut>;
-        onError?: ErrorStrategy<TState, TOut>;
-    }>): PipelineBuilder<TState & TOut, TInit>;
-    /**
-     * Add a pipeline-level gate.
-     *
-     * When the predicate returns false, all subsequent entries are skipped.
-     */
-    gate(predicate: GateFn<TState>, options?: {
-        name?: string;
-    }): PipelineBuilder<TState, TInit>;
-    /**
-     * Add a pipeline-level branch (if/else fork).
-     *
-     * When the condition returns true, the `true` path executes;
-     * otherwise the optional `false` path executes.
-     * Both branches must produce the same output type `TOut`.
-     */
-    branch<TOut extends Record<string, any>>(condition: GateFn<TState>, paths: {
-        true: (b: PipelineBuilder<TState, TState>) => PipelineBuilder<TState & TOut, TState>;
-        false?: (b: PipelineBuilder<TState, TState>) => PipelineBuilder<TState & TOut, TState>;
-    }, options?: {
-        name?: string;
-    }): PipelineBuilder<TState & TOut, TInit>;
-    /**
-     * Finalize the pipeline definition.
-     *
-     * Returns the frozen list of entries for the runner to execute.
-     */
-    build(): Pipeline<TState, TInit>;
-}
-export declare class Pipeline<TState extends Record<string, any>, TInit extends Record<string, any> = TState> {
-    constructor(entries: readonly PipelineEntry<TState>[]);
-}
-//# sourceMappingURL=PipelineBuilder.d.ts.map

package/dist/sdk/pipeline/PipelineBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PipelineBuilder.d.ts","sourceRoot":"","sources":["../../../src/sdk/pipeline/PipelineBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAKV,aAAa,EACb,MAAM,EACN,MAAM,EACN,aAAa,EACd,MAAM,YAAY,CAAC;AAMpB,MAAM,WAAW,WAAW,CAAC,MAAM,EAAE,IAAI;IACvC,kDAAkD;IAClD,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;CACvC;AAMD;;;;;;GAMG;AACH,qBAAa,eAAe,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM;gBAI7F,OAAO,GAAE,aAAa,CAAC,MAAM,CAAC,EAAO;IAIjD;;;;;OAKG;IACH,IAAI,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnC,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EACxB,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,GAClC,eAAe,CAAC,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC;IAaxC;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACvC,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QACzB,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;KACvC,CAAC,GACD,eAAe,CAAC,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC;IAexC;;;;OAIG;IACH,IAAI,CACF,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EACzB,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAC1B,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC;IAYjC;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,EACzB,KAAK,EAAE;QACL,IAAI,EAAE,CAAC,CAAC,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,eAAe,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;QACrF,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,eAAe,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;KACxF,EACD,OAAO,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAC1B,eAAe,CAAC,MAAM,GAAG,IAAI,EAAE,KAAK,CAAC;IAmBxC;;;;OAIG;IACH,KAAK,IAAI,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;CAGjC;AAMD,qBAAa,QAAQ,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM;gBAItF,OAAO,EAAE,SAAS,aAAa,CAAC,MAAM,CAAC,EAAE;CAGtD"}

package/dist/sdk/pipeline/PipelineBuilder.js

@@ -1,129 +0,0 @@
-/**
- * Fluent builder for constructing typed pipelines.
- *
- * Usage:
- *   const pipeline = sdkPipeline<{ repo: string }>()
- *     .step('lint', async ({ state, run }) => {
- *       const result = await run('lint', { args: { path: state.repo } });
- *       return { lintOutput: result.result.final_output };
- *     })
- *     .step('review', async ({ state, run }) => {
- *       const result = await run('review', { extraInstructions: state.lintOutput });
- *       return { reviewOutput: result.result.final_output };
- *     })
- *     .build();
- */
-// ---------------------------------------------------------------------------
-// Builder
-// ---------------------------------------------------------------------------
-/**
- * Immutable pipeline builder that tracks accumulated state type TState.
- *
- * Each .step() call produces a new builder whose TState is the intersection
- * of the previous state and the step's output type. This gives full type
- * inference through the chain without explicit generics at each step.
- */
-export class PipelineBuilder {
-    /** @internal */
-    _entries;
-    constructor(entries = []) {
-        this._entries = entries;
-    }
-    /**
-     * Add a sequential step to the pipeline.
-     *
-     * The step function receives the accumulated state and must return an
-     * object whose keys are merged into the state for subsequent steps.
-     */
-    step(name, fn, options) {
-        const entry = {
-            name,
-            fn,
-            onError: options?.onError ?? 'throw',
-        };
-        // Cast is safe: we widen TState to TState & TOut going forward
-        return new PipelineBuilder([
-            ...this._entries,
-            entry,
-        ]);
-    }
-    /**
-     * Add a group of steps that execute in parallel.
-     *
-     * All steps in the group receive the same snapshot of state. Their
-     * outputs are merged (Object.assign order matches declaration order).
-     */
-    parallel(steps) {
-        const group = {
-            kind: 'parallel',
-            steps: steps.map((s) => ({
-                name: s.name,
-                fn: s.fn,
-                onError: s.onError ?? 'throw',
-            })),
-        };
-        return new PipelineBuilder([
-            ...this._entries,
-            group,
-        ]);
-    }
-    /**
-     * Add a pipeline-level gate.
-     *
-     * When the predicate returns false, all subsequent entries are skipped.
-     */
-    gate(predicate, options) {
-        const entry = {
-            kind: 'gate',
-            name: options?.name ?? `gate-${this._entries.length}`,
-            fn: predicate,
-        };
-        return new PipelineBuilder([
-            ...this._entries,
-            entry,
-        ]);
-    }
-    /**
-     * Add a pipeline-level branch (if/else fork).
-     *
-     * When the condition returns true, the `true` path executes;
-     * otherwise the optional `false` path executes.
-     * Both branches must produce the same output type `TOut`.
-     */
-    branch(condition, paths, options) {
-        const trueBranch = paths.true(new PipelineBuilder());
-        const falseBranch = paths.false
-            ? paths.false(new PipelineBuilder())
-            : new PipelineBuilder();
-        const entry = {
-            kind: 'branch',
-            name: options?.name ?? `branch-${this._entries.length}`,
-            condition,
-            trueEntries: Object.freeze([...trueBranch._entries]),
-            falseEntries: Object.freeze([...falseBranch._entries]),
-        };
-        return new PipelineBuilder([
-            ...this._entries,
-            entry,
-        ]);
-    }
-    /**
-     * Finalize the pipeline definition.
-     *
-     * Returns the frozen list of entries for the runner to execute.
-     */
-    build() {
-        return new Pipeline(Object.freeze([...this._entries]));
-    }
-}
-// ---------------------------------------------------------------------------
-// Pipeline (frozen, executable definition)
-// ---------------------------------------------------------------------------
-export class Pipeline {
-    /** @internal */
-    entries;
-    constructor(entries) {
-        this.entries = entries;
-    }
-}
-//# sourceMappingURL=PipelineBuilder.js.map

package/dist/sdk/pipeline/PipelineBuilder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PipelineBuilder.js","sourceRoot":"","sources":["../../../src/sdk/pipeline/PipelineBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAsBH,8EAA8E;AAC9E,UAAU;AACV,8EAA8E;AAE9E;;;;;;GAMG;AACH,MAAM,OAAO,eAAe;IAC1B,gBAAgB;IACP,QAAQ,CAA0B;IAE3C,YAAY,UAAmC,EAAE;QAC/C,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,IAAI,CACF,IAAY,EACZ,EAAwB,EACxB,OAAmC;QAEnC,MAAM,KAAK,GAA+B;YACxC,IAAI;YACJ,EAAE;YACF,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,OAAO;SACrC,CAAC;QACF,+DAA+D;QAC/D,OAAO,IAAI,eAAe,CAAuB;YAC/C,GAAG,IAAI,CAAC,QAAiB;YACzB,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CACN,KAIE;QAEF,MAAM,KAAK,GAA0B;YACnC,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBACvB,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,EAAE,EAAE,CAAC,CAAC,EAAyB;gBAC/B,OAAO,EAAE,CAAC,CAAC,OAAO,IAAI,OAAO;aAC9B,CAAC,CAAC;SACJ,CAAC;QACF,OAAO,IAAI,eAAe,CAAuB;YAC/C,GAAG,IAAI,CAAC,QAAiB;YACzB,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,IAAI,CACF,SAAyB,EACzB,OAA2B;QAE3B,MAAM,KAAK,GAAyB;YAClC,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YACrD,EAAE,EAAE,SAAS;SACd,CAAC;QACF,OAAO,IAAI,eAAe,CAAgB;YACxC,GAAG,IAAI,CAAC,QAAiB;YACzB,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACH,MAAM,CACJ,SAAyB,EACzB,KAGC,EACD,OAA2B;QAE3B,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,eAAe,EAAkB,CAAC,CAAC;QACrE,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK;YAC7B,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,eAAe,EAAkB,CAAC;YACpD,CAAC,CAAC,IAAI,eAAe,EAAkB,CAAC;QAE1C,MAAM,KAAK,GAA2B;YACpC,IAAI,EAAE,QAAQ;YACd,IAAI,EAAE,OAAO,EAAE,IAAI,IAAI,UAAU,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;YACvD,SAAS;YACT,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,CAA4B;YAC/E,YAAY,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,CAA4B;SAClF,CAAC;QACF,OAAO,IAAI,eAAe,CAAuB;YAC/C,GAAG,IAAI,CAAC,QAAiB;YACzB,KAAK;SACN,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACH,KAAK;QACH,OAAO,IAAI,QAAQ,CAAgB,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAA4B,CAAC,CAAC;IACnG,CAAC;CACF;AAED,8EAA8E;AAC9E,2CAA2C;AAC3C,8EAA8E;AAE9E,MAAM,OAAO,QAAQ;IACnB,gBAAgB;IACP,OAAO,CAAmC;IAEnD,YAAY,OAAyC;QACnD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF"}

package/dist/sdk/pipeline/PipelineRunner.d.ts

@@ -1,28 +0,0 @@
-/**
- * Executes a Pipeline definition against a QodoSDK instance.
- *
- * The runner is intentionally decoupled from the builder so that a single
- * pipeline definition can be executed multiple times with different SDK
- * instances and initial states.
- */
-import type { QodoSDK } from '../QodoSDK.js';
-import type { Pipeline } from './PipelineBuilder.js';
-import type { PipelineResult } from './types.js';
-import type { QodoSdkEvent } from '../events.js';
-export declare class PipelineExecutionError extends Error {
-    readonly stepName: string;
-    readonly cause?: Error | undefined;
-    constructor(message: string, stepName: string, cause?: Error | undefined);
-}
-/**
- * Callback type for pipeline event notifications.
- */
-export interface PipelineEventCallback {
-    (event: QodoSdkEvent): void;
-}
-/**
- * Execute a pipeline with the given SDK instance and initial state.
- * Optionally accepts an event callback to receive pipeline execution events.
- */
-export declare function runPipeline<TState extends Record<string, any>, TInit extends Record<string, any> = TState>(sdk: QodoSDK, pipeline: Pipeline<TState, TInit>, initialState: TInit, onEvent?: PipelineEventCallback): Promise<PipelineResult<TState>>;
-//# sourceMappingURL=PipelineRunner.d.ts.map

package/dist/sdk/pipeline/PipelineRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PipelineRunner.d.ts","sourceRoot":"","sources":["../../../src/sdk/pipeline/PipelineRunner.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAuC,MAAM,eAAe,CAAC;AAClF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAMV,cAAc,EAGf,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGjD,qBAAa,sBAAuB,SAAQ,KAAK;aAG7B,QAAQ,EAAE,MAAM;aAChB,KAAK,CAAC,EAAE,KAAK;gBAF7B,OAAO,EAAE,MAAM,EACC,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,KAAK,YAAA;CAKhC;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,EAC9G,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC,EACjC,YAAY,EAAE,KAAK,EACnB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAoFjC"}

package/dist/sdk/pipeline/PipelineRunner.js

@@ -1,326 +0,0 @@
-/**
- * Executes a Pipeline definition against a QodoSDK instance.
- *
- * The runner is intentionally decoupled from the builder so that a single
- * pipeline definition can be executed multiple times with different SDK
- * instances and initial states.
- */
-import { SdkEventType, SDK_PROTOCOL_V2 } from '../events.js';
-export class PipelineExecutionError extends Error {
-    stepName;
-    cause;
-    constructor(message, stepName, cause) {
-        super(message);
-        this.stepName = stepName;
-        this.cause = cause;
-        this.name = 'PipelineExecutionError';
-    }
-}
-/**
- * Execute a pipeline with the given SDK instance and initial state.
- * Optionally accepts an event callback to receive pipeline execution events.
- */
-export async function runPipeline(sdk, pipeline, initialState, onEvent) {
-    const pipelineStart = Date.now();
-    // State starts as TInit and accumulates step outputs to become TState at runtime
-    let state = { ...initialState };
-    const stepLogs = [];
-    let seq = 0;
-    const runId = `pipeline-${Date.now()}`;
-    // Collect all step names for the started event.
-    const allStepNames = collectStepNames(pipeline);
-    emitEvent(onEvent, runId, seq++, SdkEventType.PipelineStarted, {
-        entry_count: pipeline.entries.length,
-        step_names: allStepNames,
-    });
-    try {
-        const entries = pipeline.entries;
-        for (let i = 0; i < entries.length; i++) {
-            const entry = entries[i];
-            if (isPipelineGate(entry)) {
-                const { passed, nextSeq } = await evaluatePipelineGate(entry, state, onEvent, runId, seq);
-                seq = nextSeq;
-                if (!passed) {
-                    for (let j = i + 1; j < entries.length; j++) {
-                        addSkipLogs(entries[j], stepLogs);
-                    }
-                    break;
-                }
-                continue;
-            }
-            if (isPipelineBranch(entry)) {
-                const { newState, logs, nextSeq } = await executeBranch(sdk, entry, state, onEvent, runId, seq);
-                seq = nextSeq;
-                state = { ...state, ...newState };
-                stepLogs.push(...logs);
-                continue;
-            }
-            if (isParallelGroup(entry)) {
-                const { newState, logs, nextSeq } = await executeParallelGroup(sdk, entry, state, onEvent, runId, seq);
-                seq = nextSeq;
-                state = { ...state, ...newState };
-                stepLogs.push(...logs);
-            }
-            else {
-                const { newState, log, nextSeq } = await executeStep(sdk, entry, state, false, onEvent, runId, seq);
-                seq = nextSeq;
-                state = { ...state, ...newState };
-                stepLogs.push(log);
-            }
-        }
-        const completed = stepLogs.filter((s) => s.status === 'completed').length;
-        const skipped = stepLogs.filter((s) => s.status === 'skipped').length;
-        emitEvent(onEvent, runId, seq++, SdkEventType.PipelineCompleted, {
-            duration_ms: Date.now() - pipelineStart,
-            steps_completed: completed,
-            steps_skipped: skipped,
-        });
-        return { state, steps: stepLogs };
-    }
-    catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        const stepName = err instanceof PipelineExecutionError ? err.stepName : 'unknown';
-        emitEvent(onEvent, runId, seq++, SdkEventType.PipelineError, {
-            step_name: stepName,
-            message: error.message,
-            cause: err instanceof PipelineExecutionError ? err.cause : undefined,
-        });
-        throw err;
-    }
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function isParallelGroup(entry) {
-    return entry.kind === 'parallel';
-}
-function isPipelineGate(entry) {
-    return entry.kind === 'gate';
-}
-function isPipelineBranch(entry) {
-    return entry.kind === 'branch';
-}
-function collectEntryNames(entries) {
-    const names = [];
-    for (const entry of entries) {
-        if (isPipelineGate(entry)) {
-            names.push(entry.name);
-        }
-        else if (isPipelineBranch(entry)) {
-            names.push(entry.name);
-            names.push(...collectEntryNames(entry.trueEntries));
-            names.push(...collectEntryNames(entry.falseEntries));
-        }
-        else if (isParallelGroup(entry)) {
-            for (const step of entry.steps) {
-                names.push(step.name);
-            }
-        }
-        else {
-            names.push(entry.name);
-        }
-    }
-    return names;
-}
-function collectStepNames(pipeline) {
-    return collectEntryNames(pipeline.entries);
-}
-function emitEvent(onEvent, runId, seq, type, data) {
-    if (!onEvent)
-        return;
-    onEvent({
-        protocol: SDK_PROTOCOL_V2,
-        type,
-        timestamp: Date.now(),
-        seq,
-        run_id: runId,
-        session_id: '',
-        data,
-    });
-}
-async function evaluatePipelineGate(gate, state, onEvent, runId, seq) {
-    let passed;
-    try {
-        passed = await gate.fn(state);
-    }
-    catch {
-        passed = false;
-    }
-    emitEvent(onEvent, runId, seq++, SdkEventType.PipelineGateEvaluated, {
-        step_name: gate.name,
-        passed,
-        pipeline_level: true,
-    });
-    return { passed, nextSeq: seq };
-}
-async function executeBranch(sdk, branch, state, onEvent, runId, seq) {
-    let conditionResult;
-    try {
-        conditionResult = await branch.condition(state);
-    }
-    catch {
-        conditionResult = false;
-    }
-    emitEvent(onEvent, runId, seq++, SdkEventType.PipelineBranchEvaluated, {
-        branch_name: branch.name,
-        condition_result: conditionResult,
-    });
-    const chosenEntries = conditionResult ? branch.trueEntries : branch.falseEntries;
-    const skippedEntries = conditionResult ? branch.falseEntries : branch.trueEntries;
-    const logs = [];
-    let branchState = {};
-    // Execute chosen path entries sequentially
-    let currentState = state;
-    for (let i = 0; i < chosenEntries.length; i++) {
-        const entry = chosenEntries[i];
-        if (isPipelineGate(entry)) {
-            const { passed, nextSeq } = await evaluatePipelineGate(entry, currentState, onEvent, runId, seq);
-            seq = nextSeq;
-            if (!passed) {
-                for (let j = i + 1; j < chosenEntries.length; j++) {
-                    addSkipLogs(chosenEntries[j], logs);
-                }
-                break;
-            }
-            continue;
-        }
-        if (isPipelineBranch(entry)) {
-            const { newState, logs: branchLogs, nextSeq } = await executeBranch(sdk, entry, currentState, onEvent, runId, seq);
-            seq = nextSeq;
-            currentState = { ...currentState, ...newState };
-            branchState = { ...branchState, ...newState };
-            logs.push(...branchLogs);
-            continue;
-        }
-        if (isParallelGroup(entry)) {
-            const { newState, logs: groupLogs, nextSeq } = await executeParallelGroup(sdk, entry, currentState, onEvent, runId, seq);
-            seq = nextSeq;
-            currentState = { ...currentState, ...newState };
-            branchState = { ...branchState, ...newState };
-            logs.push(...groupLogs);
-        }
-        else {
-            const { newState, log, nextSeq } = await executeStep(sdk, entry, currentState, false, onEvent, runId, seq);
-            seq = nextSeq;
-            currentState = { ...currentState, ...newState };
-            branchState = { ...branchState, ...newState };
-            logs.push(log);
-        }
-    }
-    // Add skip logs for the non-taken path
-    for (const entry of skippedEntries) {
-        addSkipLogs(entry, logs);
-    }
-    // Add a branch log entry
-    logs.unshift({
-        name: branch.name,
-        status: 'completed',
-        durationMs: 0,
-        branchTaken: conditionResult ? 'true' : 'false',
-    });
-    return { newState: branchState, logs, nextSeq: seq };
-}
-function addSkipLogs(entry, logs) {
-    if (isPipelineGate(entry)) {
-        logs.push({ name: entry.name, status: 'skipped', durationMs: 0 });
-    }
-    else if (isPipelineBranch(entry)) {
-        logs.push({ name: entry.name, status: 'skipped', durationMs: 0 });
-        for (const sub of entry.trueEntries)
-            addSkipLogs(sub, logs);
-        for (const sub of entry.falseEntries)
-            addSkipLogs(sub, logs);
-    }
-    else if (isParallelGroup(entry)) {
-        for (const step of entry.steps) {
-            logs.push({ name: step.name, status: 'skipped', durationMs: 0 });
-        }
-    }
-    else {
-        logs.push({ name: entry.name, status: 'skipped', durationMs: 0 });
-    }
-}
-async function executeStep(sdk, step, state, parallel, onEvent, runId, seq) {
-    const start = Date.now();
-    emitEvent(onEvent, runId, seq++, SdkEventType.PipelineStepStarted, {
-        step_name: step.name,
-        parallel,
-    });
-    // Build step context
-    const ctx = {
-        state,
-        run: (commandOrPrompt, options) => {
-            return sdk.run(commandOrPrompt, options);
-        },
-        stepName: step.name,
-    };
-    try {
-        const output = await step.fn(ctx);
-        const log = { name: step.name, status: 'completed', durationMs: Date.now() - start };
-        emitEvent(onEvent, runId, seq++, SdkEventType.PipelineStepCompleted, {
-            step_name: step.name,
-            status: 'completed',
-            duration_ms: log.durationMs,
-        });
-        return { newState: output ?? {}, log, nextSeq: seq };
-    }
-    catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        if (step.onError === 'skip') {
-            const log = {
-                name: step.name,
-                status: 'skipped',
-                durationMs: Date.now() - start,
-                error: error.message,
-            };
-            emitEvent(onEvent, runId, seq++, SdkEventType.PipelineStepCompleted, {
-                step_name: step.name,
-                status: 'skipped',
-                duration_ms: log.durationMs,
-                error: error.message,
-            });
-            return { newState: {}, log, nextSeq: seq };
-        }
-        if (typeof step.onError === 'function') {
-            try {
-                const recovered = await step.onError(error, state);
-                const log = { name: step.name, status: 'completed', durationMs: Date.now() - start };
-                emitEvent(onEvent, runId, seq++, SdkEventType.PipelineStepCompleted, {
-                    step_name: step.name,
-                    status: 'completed',
-                    duration_ms: log.durationMs,
-                });
-                return { newState: recovered ?? {}, log, nextSeq: seq };
-            }
-            catch (recoveryErr) {
-                throw new PipelineExecutionError(`Step "${step.name}" recovery failed: ${recoveryErr?.message || recoveryErr}`, step.name, recoveryErr instanceof Error ? recoveryErr : undefined);
-            }
-        }
-        // 'throw' (default)
-        throw new PipelineExecutionError(`Step "${step.name}" failed: ${error.message}`, step.name, error);
-    }
-}
-async function executeParallelGroup(sdk, group, state, onEvent, runId, seq) {
-    // Each parallel step gets its own starting seq to avoid conflicts.
-    // We'll collect events and replay them after all settle.
-    const results = await Promise.allSettled(group.steps.map((step, i) => executeStep(sdk, step, state, true, onEvent, runId, seq + (i * 10))));
-    // Advance seq past all parallel steps.
-    seq += group.steps.length * 10;
-    let merged = {};
-    const logs = [];
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result.status === 'fulfilled') {
-            merged = { ...merged, ...result.value.newState };
-            logs.push(result.value.log);
-        }
-        else {
-            // If any parallel step throws (after its own onError handling),
-            // the entire parallel group fails.
-            const stepName = group.steps[i].name;
-            throw new PipelineExecutionError(`Parallel step "${stepName}" failed: ${result.reason?.message || result.reason}`, stepName, result.reason instanceof Error ? result.reason : undefined);
-        }
-    }
-    return { newState: merged, logs, nextSeq: seq };
-}
-//# sourceMappingURL=PipelineRunner.js.map