@wrongstack/core 0.1.9 → 0.2.0

package/dist/agent-bridge-DmBiCipY.d.ts

@@ -0,0 +1,33 @@
+import { p as BridgeTransport, q as BridgeMessage, A as AgentBridge, r as AgentBridgeConfig } from './multi-agent-BDfkxL5C.js';
+
+/**
+ * In-memory pub/sub transport for agent-to-agent messaging.
+ * Subscribers register by agentId and receive messages via callback.
+ */
+declare class InMemoryBridgeTransport implements BridgeTransport {
+    private readonly subs;
+    send(msg: BridgeMessage, to: string): Promise<void>;
+    subscribe(agentId: string, handler: (msg: BridgeMessage) => void): () => void;
+    close(agentId: string): Promise<void>;
+}
+
+declare class InMemoryAgentBridge implements AgentBridge {
+    readonly agentId: string;
+    readonly coordinatorId: string;
+    private readonly transport;
+    private readonly subscriptions;
+    private readonly pendingRequests;
+    private stopped;
+    private timeoutMs;
+    /** Guards request() so concurrent calls on the same id can't silently overwrite. */
+    private readonly inflightGuards;
+    constructor(config: AgentBridgeConfig, transport: BridgeTransport);
+    send(msg: BridgeMessage): Promise<void>;
+    broadcast(msg: BridgeMessage): Promise<void>;
+    subscribe(handler: (msg: BridgeMessage) => void | Promise<void>): () => void;
+    request<T>(msg: BridgeMessage, timeoutMs?: number): Promise<BridgeMessage<T>>;
+    stop(): Promise<void>;
+}
+declare function createMessage<T = unknown>(type: BridgeMessage['type'], from: string, payload: T, to?: string): BridgeMessage<T>;
+
+export { InMemoryAgentBridge as I, InMemoryBridgeTransport as a, createMessage as c };

package/dist/compactor-DSl2FK7a.d.ts

@@ -0,0 +1,17 @@
+import { a0 as Context } from './context-u0bryklF.js';
+
+interface CompactReport {
+    before: number;
+    after: number;
+    reductions: {
+        phase: 'elision' | 'summary' | 'selective';
+        saved: number;
+    }[];
+}
+interface Compactor {
+    compact(ctx: Context, opts?: {
+        aggressive?: boolean;
+    }): Promise<CompactReport>;
+}
+
+export type { Compactor as C, CompactReport as a };

package/dist/config-DXrqb41m.d.ts

@@ -0,0 +1,193 @@
+import { W as WireFamily } from './models-registry-Y2xbog0E.js';
+import { P as Permission } from './context-u0bryklF.js';
+
+interface ContextConfig {
+    warnThreshold: number;
+    softThreshold: number;
+    hardThreshold: number;
+    /** Enable automatic compaction when thresholds are crossed (default: true). */
+    autoCompact?: boolean;
+    /**
+     * Model used for LLM-assisted summarization in IntelligentCompactor.
+     * Falls back to the main model when omitted.
+     */
+    summarizerModel?: string;
+    /**
+     * Override the effective context window size (in tokens). Use this when
+     * you want the compactor to trigger earlier than the provider's actual
+     * maxContext. Defaults to the provider's reported maxContext.
+     */
+    effectiveMaxContext?: number;
+    maxSessionTokens?: number;
+    maxDailyTokens?: number;
+    preserveK: number;
+    eliseThreshold: number;
+    /** Compactor strategy: 'hybrid' (default, fast rules), 'intelligent' (LLM summarization), 'selective' (LLM-driven selection). */
+    strategy?: 'hybrid' | 'intelligent' | 'selective';
+    /** Enable LLM-driven selective compaction (default: false for backward compat). */
+    llmSelector?: boolean;
+}
+interface ToolsConfig {
+    defaultExecutionStrategy: 'parallel' | 'sequential' | 'smart';
+    maxIterations: number;
+    iterationTimeoutMs: number;
+    sessionTimeoutMs: number;
+    perIterationOutputCapBytes: number;
+    /**
+     * When true (default), the agent automatically extends its iteration
+     * limit by 100 when hit. Set to false to require user confirmation.
+     */
+    autoExtendLimit?: boolean;
+}
+interface ProviderApiKey {
+    /** Short human-readable label (e.g. "personal", "work", "rate-limit-backup"). */
+    label: string;
+    /**
+     * The key itself. The field name contains `apiKey` so the secret-vault
+     * walker will encrypt it on write and decrypt it on read.
+     */
+    apiKey: string;
+    /** ISO-8601 timestamp the key was added. */
+    createdAt: string;
+}
+interface ProviderConfig {
+    type: string;
+    /**
+     * Legacy single-key field. Still honored as a fallback when `apiKeys`
+     * is empty. When `apiKeys`/`activeKey` are present, the config loader
+     * mirrors the active entry into this field so downstream consumers
+     * (provider construction, wire adapters) need no changes.
+     */
+    apiKey?: string;
+    /** Multiple keys for the same provider — pick one with `activeKey`. */
+    apiKeys?: ProviderApiKey[];
+    /** Label of the entry in `apiKeys` to use. Defaults to the first one. */
+    activeKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    model?: string;
+    quirks?: Record<string, unknown>;
+    capabilities?: Record<string, unknown>;
+    /**
+     * Optional wire-family override. When present, the provider can be
+     * constructed without consulting the models.dev catalog — useful for
+     * self-hosted endpoints, internal proxies, or for working offline.
+     */
+    family?: WireFamily;
+    /** Custom env var names to probe when `apiKey` is missing. */
+    envVars?: string[];
+    /** Optional list of models the user wants visible for this provider. */
+    models?: string[];
+}
+interface MCPServerConfig {
+    /** Human-readable description shown in `wstack mcp list`. */
+    description?: string;
+    name: string;
+    transport: 'stdio' | 'sse' | 'streamable-http';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    enabled?: boolean;
+    allowedTools?: string[];
+    permission?: Permission;
+    startupTimeoutMs?: number;
+}
+interface LogConfig {
+    level: 'error' | 'warn' | 'info' | 'debug' | 'trace';
+    file?: string;
+}
+interface PluginConfig {
+    name: string;
+    enabled?: boolean;
+    options?: Record<string, unknown>;
+}
+/**
+ * Optional subsystems that the CLI can boot without. The core flow
+ * (provider + agent loop + bundled tools + session) always works; these
+ * just add capabilities. `--no-features` flips all of these off, which
+ * is the minimum viable WrongStack: a single provider, a fixed config,
+ * no network calls at startup.
+ */
+interface FeaturesConfig {
+    /** Load MCP servers declared in `mcpServers`. */
+    mcp: boolean;
+    /** Load + initialise npm plugins declared in `plugins`. */
+    plugins: boolean;
+    /** Register `remember` / `forget` tools backed by memory store. */
+    memory: boolean;
+    /** Fetch the models.dev catalog at startup. When false, the provider
+     *  must declare its `family` explicitly in `providers[<id>]`. */
+    modelsRegistry: boolean;
+    /** Discover + load skills from disk. */
+    skills: boolean;
+}
+interface Config {
+    version: 1;
+    provider: string;
+    model: string;
+    apiKey?: string;
+    baseUrl?: string;
+    providers?: Record<string, ProviderConfig>;
+    context: ContextConfig;
+    tools: ToolsConfig;
+    mcpServers?: Record<string, MCPServerConfig>;
+    plugins?: (string | PluginConfig)[];
+    log: LogConfig;
+    features: FeaturesConfig;
+    yolo?: boolean;
+    cwd?: string;
+    /**
+     * Per-plugin namespaced config sections. Each plugin reads its own
+     * subtree via `ConfigStore.getExtension(pluginName)`. Plugins should
+     * declare a `configSchema` so the loader validates this section
+     * automatically before `setup()` runs.
+     *
+     * Example:
+     *   extensions: {
+     *     'wstack-auth': { tokenUrl: 'https://...', refreshBefore: 300 },
+     *     'wstack-metrics': { sink: 'prometheus', port: 9090 },
+     *   }
+     */
+    extensions?: Record<string, Record<string, unknown>>;
+}
+interface ConfigLoader {
+    load(opts?: {
+        cliFlags?: Partial<Config>;
+        cwd?: string;
+    }): Promise<Config>;
+}
+/**
+ * Subscribable view over Config. Plugins and CLI subsystems use this instead
+ * of holding a frozen Config reference, so they can react to runtime updates
+ * (e.g. `/model` switching the active provider, secrets rotation, dynamic
+ * extension reload).
+ *
+ * The store enforces immutability — `get()` always returns a frozen object.
+ * Updates happen through `update(partial)`, which produces a new Config
+ * (structurally cloned, then frozen) and notifies watchers.
+ */
+interface ConfigStore {
+    get(): Readonly<Config>;
+    /**
+     * Get a typed top-level section. Convenience for consumers that only
+     * care about one slice (e.g. `tools` or `context`).
+     */
+    getSection<K extends keyof Config>(key: K): Readonly<Config[K]>;
+    /**
+     * Return the extension namespace for `pluginName`, or an empty record
+     * when none is configured. The returned object is frozen.
+     */
+    getExtension(pluginName: string): Readonly<Record<string, unknown>>;
+    /**
+     * Apply a partial update. Returns the new Config. Watchers are notified
+     * synchronously after the update completes. Throws if the result fails
+     * any registered invariants (currently: version must stay 1).
+     */
+    update(partial: Partial<Config>): Readonly<Config>;
+    /** Subscribe to changes. Returns an unsubscribe function. */
+    watch(cb: (next: Readonly<Config>, prev: Readonly<Config>) => void): () => void;
+}
+
+export type { Config as C, FeaturesConfig as F, LogConfig as L, MCPServerConfig as M, PluginConfig as P, ToolsConfig as T, ConfigLoader as a, ConfigStore as b, ContextConfig as c, ProviderApiKey as d, ProviderConfig as e };