@wrongstack/core 0.155.0 → 0.250.0

package/dist/pipeline-BG7UgbDc.d.ts

@@ -1,239 +0,0 @@
-import { T as Tool, l as TextBlock, g as ContentBlock } from './context-C7G_MtLV.js';
-import { H as HookEvent, e as HookMatcher, I as InProcessHook, S as ShellHook, f as HookEntry } from './config-BaVThgnT.js';
-
-/** Model capabilities relevant to prompt composition. */
-interface ModelCapabilities {
-    maxContextTokens: number;
-    supportsTools: boolean;
-    supportsVision: boolean;
-    supportsReasoning: boolean;
-}
-interface BuildContext {
-    cwd: string;
-    projectRoot: string;
-    tools: Tool[];
-    /** Provider id (e.g. "anthropic", "minimax-coding-plan"). */
-    provider?: string | undefined;
-    /** Model id (e.g. "claude-sonnet-4-6", "MiniMax-M2.7"). */
-    model?: string | undefined;
-    /**
-     * True when the prompt is being built for a SUBAGENT, not the host
-     * agent. Subagents are scoped to a single task — they should NOT see
-     * the host's strategic plan board (which is anchoring the host across
-     * turns, not steering individual subtasks). The plan-injection
-     * layer short-circuits when this flag is set.
-     */
-    subagent?: boolean | undefined;
-}
-interface SystemPromptBuilder {
-    build(ctx: BuildContext): Promise<TextBlock[]>;
-}
-
-/**
- * Registry of lifecycle hooks (both in-process and shell). One instance is
- * shared per session: the boot path loads `config.hooks` as shell entries and
- * plugins add in-process entries via `PluginAPI.registerHook`. The
- * `HookRunner` reads from it at each lifecycle phase.
- */
-declare class HookRegistry {
-    private readonly entries;
-    /** Register an in-process hook. Returns an unsubscribe function. */
-    registerInProcess(event: HookEvent, matcher: HookMatcher | undefined, hook: InProcessHook, owner?: string | undefined): () => void;
-    /** Register a single shell hook. Returns an unsubscribe function. */
-    registerShell(event: HookEvent, hook: ShellHook): () => void;
-    /** Bulk-load shell hooks from a `config.hooks` map. */
-    loadShellHooks(hooks: Partial<Record<HookEvent, ShellHook[]>> | undefined): void;
-    /** All entries registered for an event, in registration order. */
-    list(event: HookEvent): readonly HookEntry[];
-    /** True when any entry is registered for the event. */
-    has(event: HookEvent): boolean;
-    /** Drop every registered hook (used in teardown / tests). */
-    clear(): void;
-    private remove;
-}
-/**
- * Does a hook matcher apply to a tool name? `*` (or empty) matches everything;
- * otherwise the matcher is a case-insensitive pipe-delimited list of exact
- * tool names (`"edit|write"`). Non-tool events pass `undefined` and always match.
- */
-declare function hookMatcherMatches(matcher: HookMatcher, toolName: string | undefined): boolean;
-
-interface Renderer {
-    write(text: string | TextBlock): void;
-    writeLine(text?: string): void;
-    writeBlock(block: ContentBlock): void;
-    writeToolCall(name: string, input: unknown): void;
-    writeToolResult(name: string, content: unknown, isError: boolean): void;
-    writeDiff(unifiedDiff: string): void;
-    writeWarning(text: string): void;
-    writeError(text: string): void;
-    writeInfo(text: string): void;
-    clear(): void;
-}
-
-/**
- * Container — dependency injection with explicit bind / override / decorate.
- *
- * Invariants:
- *   bind()     — throws if token already bound
- *   override() — throws if nothing to replace
- *   decorate() — stacks; cached value cleared on register
- */
-type Token<T> = symbol & {
-    readonly __type?: T;
-};
-type Factory<T> = (c: Container) => T;
-type Decorator<T> = (inner: T, c: Container) => T;
-interface BindOptions {
-    singleton?: boolean | undefined;
-    owner?: string | undefined;
-}
-declare class Container {
-    private readonly entries;
-    /**
-     * Tokens currently mid-resolve. Tracked so we can detect circular
-     * dependencies (A → B → A) and throw a structured error instead of
-     * overflowing the call stack with "Maximum call stack size exceeded".
-     *
-     * Not a memoization cache — the per-entry `cache` field is the source
-     * of truth for "have I built this before?". This set only lives for
-     * the duration of a single resolve call.
-     */
-    private readonly resolving;
-    bind<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
-    override<T>(token: Token<T>, factory: Factory<T>, opts?: BindOptions): void;
-    decorate<T>(token: Token<T>, decorator: Decorator<T>, owner?: string): void;
-    resolve<T>(token: Token<T>): T;
-    /**
-     * Build a human-readable description of the dependency cycle that
-     * caused the resolution to re-enter. Lists the tokens in the order
-     * they were entered, then appends the re-entered token to close the
-     * loop. Falls back to a generic message if the resolving set is
-     * somehow empty (shouldn't happen, but defensive).
-     */
-    private describeCycle;
-    has<T>(token: Token<T>): boolean;
-    /**
-     * Resolve a token if it is bound, otherwise return undefined.
-     * Unlike resolve(), this does not throw if the token is unbound.
-     */
-    safeResolve<T>(token: Token<T>): T | undefined;
-    ownerOf<T>(token: Token<T>): string | undefined;
-    /**
-     * Remove a token's binding (along with any decorators stacked on it).
-     * Returns true if the token existed. Use this to withdraw temporary
-     * bindings installed by a short-lived run or plugin — without it, the
-     * entry persists in the map forever.
-     */
-    unbind<T>(token: Token<T>): boolean;
-    /**
-     * Drop every binding. Intended for tests and short-lived CLI invocations
-     * that rebuild the container from scratch. Production code should prefer
-     * `unbind` on the specific tokens it owns.
-     */
-    clear(): void;
-    list(): Array<{
-        token: symbol;
-        owner: string;
-    }>;
-    /**
-     * Inspect a binding's full shape, including decorator count and whether
-     * a singleton value is cached. Returns null if the token is unbound.
-     * Decorator and factory function references are not exposed — only counts
-     * and metadata, to keep internal state hidden.
-     */
-    inspect<T>(token: Token<T>): {
-        owner: string;
-        singleton: boolean;
-        decoratorCount: number;
-        cached: boolean;
-    } | null;
-}
-
-/**
- * Pipeline — Koa-style middleware chain with named middleware
- * and position-aware insertion. Generic over input type T.
- */
-type NextFn<T> = (value: T) => Promise<T>;
-type MiddlewareHandler<T> = (value: T, next: NextFn<T>) => Promise<T>;
-/**
- * Called when a middleware crashes (throws or rejects). Used by the
- * Pipeline's error boundary to log the offender without aborting the run.
- *
- * Return `'rethrow'` to propagate the error (default for core middleware),
- * or `'swallow'` to skip past the crashing middleware and continue with the
- * value the previous one produced. Plugin middleware should usually be
- * swallowed so one bad plugin can't kill an agent run.
- */
-type PipelineErrorPolicy = 'rethrow' | 'swallow';
-interface PipelineErrorEvent {
-    middleware: string;
-    owner?: string | undefined;
-    err: unknown;
-}
-type PipelineErrorHandler = (ev: PipelineErrorEvent) => PipelineErrorPolicy | Promise<PipelineErrorPolicy>;
-interface Middleware<T> {
-    name: string;
-    handler: MiddlewareHandler<T>;
-    owner?: string | undefined;
-}
-interface PipelineOptions {
-    /** When true and the target middleware is not found, operations silently no-op instead of throwing. */
-    optional?: boolean | undefined;
-}
-/**
- * Read-only view of a pipeline. Returned to consumers (plugins, hooks)
- * so they can inspect but not mutate the chain.
- */
-interface ReadonlyPipeline<T> {
-    readonly size: number;
-    list(): readonly string[];
-    run(input: T): Promise<T>;
-}
-declare class Pipeline<T> {
-    private readonly chain;
-    private errorHandler?;
-    /**
-     * Install an error boundary. When a middleware throws or rejects, the
-     * handler is called and decides whether to swallow (continue with the
-     * pre-handler value) or rethrow. Without a handler, errors propagate.
-     *
-     * Wire one per pipeline at boot — the host CLI typically installs a
-     * single boundary that logs to the operational log and emits a
-     * `pipeline.error` event for /diag.
-     */
-    setErrorHandler(handler: PipelineErrorHandler | undefined): this;
-    use(mw: Middleware<T> | Middleware<unknown>): this;
-    prepend(mw: Middleware<T>): this;
-    /**
-     * Insert middleware at an explicit index. Out-of-range indices are clamped.
-     * Use this when insertBefore/insertAfter are insufficient (e.g. to place
-     * a middleware at a known position regardless of named targets).
-     */
-    insertAt(index: number, mw: Middleware<T>): this;
-    /**
-     * Insert mw immediately before the first occurrence of target.
-     * If called multiple times with the same target, each call inserts
-     * before the target's current position — so after insertBefore('B', X)
-     * then insertBefore('B', Y), the order is Y → X → B.
-     */
-    insertBefore(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    /**
-     * Insert mw immediately after the first occurrence of target.
-     * If called multiple times with the same target, each call inserts
-     * after the target's current position — so after insertAfter('B', X)
-     * then insertAfter('B', Y), the order is B → X → Y.
-     */
-    insertAfter(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    replace(target: string, mw: Middleware<T>, opts?: PipelineOptions): this;
-    remove(name: string, opts?: PipelineOptions): this;
-    list(): readonly string[];
-    size(): number;
-    /** Return a read-only view suitable for passing to plugins. */
-    asReadonly(): ReadonlyPipeline<T>;
-    run(input: T): Promise<T>;
-    private indexOf;
-    private ensureUnique;
-}
-
-export { type BuildContext as B, Container as C, type Decorator as D, type Factory as F, HookRegistry as H, type MiddlewareHandler as M, type NextFn as N, Pipeline as P, type ReadonlyPipeline as R, type SystemPromptBuilder as S, type Token as T, type Renderer as a, type ModelCapabilities as b, type BindOptions as c, type Middleware as d, type PipelineOptions as e, hookMatcherMatches as h };