@wrongstack/core 0.1.9 → 0.2.0

package/dist/selector-BRqzvugb.d.ts

@@ -0,0 +1,51 @@
+import { M as Message } from './context-u0bryklF.js';
+
+/**
+ * Result of LLM-driven message importance analysis.
+ * The selector marks each message range with an importance tier,
+ * and optionally provides a natural-language summary for collapsed ranges.
+ */
+interface SelectorResult {
+    /**
+     * Ordered list of kept message ranges. Each entry describes a
+     * message range that should be preserved verbatim in the context.
+     */
+    kept: Array<{
+        from: number;
+        to: number;
+        importance: 'critical' | 'high' | 'medium';
+    }>;
+    /**
+     * Collapsed ranges — either replaced by the compactor or omitted.
+     * Each entry may carry a summary text produced by the LLM.
+     */
+    collapsed: Array<{
+        from: number;
+        to: number;
+        summary?: string;
+    }>;
+    /**
+     * Raw reasoning from the selector LLM (for debugging / audit).
+     */
+    reasoning: string;
+}
+/**
+ * Message selector that uses an LLM to decide which message ranges
+ * to keep vs collapse/summarize. The selector runs as a separate API
+ * call before compaction, making it more surgical than fixed-window
+ * or rules-based approaches.
+ */
+interface MessageSelector {
+    /**
+     * Analyze `messages` and return a structured plan for what to keep
+     * vs collapse. May modify the messages array in-place if needed,
+     * or return a plan that the caller (Compactor) executes.
+     *
+     * @param messages  Current message history (may be modified in-place)
+     * @param maxToKeep Token budget — selector should aim to keep total
+     *                  retained message content under this threshold
+     */
+    select(messages: Message[], maxToKeep: number): Promise<SelectorResult>;
+}
+
+export type { MessageSelector as M, SelectorResult as S };

package/dist/session-reader-C3x96CDR.d.ts

@@ -0,0 +1,150 @@
+import { b as ContentBlock, m as SessionEvent, n as SessionMetadata, o as SessionStore } from './context-u0bryklF.js';
+
+type AttachmentKind = 'text' | 'image' | 'file';
+interface AttachmentMeta {
+    /** Display label for the placeholder e.g. "123 lines" or "PNG 412 KB". */
+    label?: string;
+    /** Original filename if known. */
+    filename?: string;
+    /** MIME type if known. Required for images. */
+    mediaType?: string;
+}
+interface Attachment {
+    readonly id: string;
+    readonly kind: AttachmentKind;
+    readonly meta: AttachmentMeta;
+    /** In-memory payload. For images this is base64; for text/file it's the raw text. */
+    readonly data?: string;
+    /** Disk location if spooled. Mutually exclusive with `data` for large payloads. */
+    readonly path?: string;
+    readonly bytes: number;
+    readonly createdAt: string;
+}
+interface AttachmentRef {
+    readonly id: string;
+    readonly kind: AttachmentKind;
+    /** Index for display, e.g. `#1`. Stable for the lifetime of a session. */
+    readonly seq: number;
+    readonly meta: AttachmentMeta;
+}
+interface AddAttachmentInput {
+    kind: AttachmentKind;
+    data: string;
+    meta?: AttachmentMeta;
+}
+/**
+ * Session-scoped store for content that is too big to inline in display
+ * but must be sent to the model as a real ContentBlock. The input layer
+ * (CLI/TUI) puts pasted text, dropped files, and pasted images here, gets
+ * back a stable AttachmentRef, and shows a placeholder like `[pasted #1]`
+ * to the user. At submit time, `expand()` swaps placeholders for the real
+ * payload as ContentBlock[].
+ */
+interface AttachmentStore {
+    add(input: AddAttachmentInput): Promise<AttachmentRef>;
+    get(id: string): Promise<Attachment | undefined>;
+    list(): AttachmentRef[];
+    /**
+     * Replace all known placeholder tokens in `text` (e.g. `[pasted #1]`,
+     * `[image #2]`) with the corresponding ContentBlock(s) and return the
+     * mixed array. Unknown placeholders are left as plain text.
+     */
+    expand(text: string): Promise<ContentBlock[]>;
+    clear(): Promise<void>;
+}
+
+/**
+ * L2-A: SessionReader — query, replay, search, export over a `SessionStore`.
+ *
+ * Keeps a clean read-only interface (no `append`, no `delete`) so analytics
+ * code can be wired against a store without granting it the writer surface.
+ */
+type SessionEventType = SessionEvent['type'];
+interface SessionQuery {
+    /** Filter by start timestamp (ISO). Sessions started before this are excluded. */
+    since?: string;
+    /** Filter by start timestamp (ISO). Sessions started after this are excluded. */
+    until?: string;
+    /** Substring match against title (case-insensitive). */
+    titleContains?: string;
+    /** Filter by provider id. */
+    provider?: string;
+    /** Filter by model id. */
+    model?: string;
+    /** Minimum total tokens (input+output) to keep. */
+    minTokens?: number;
+    /** Limit result count. Defaults to no limit. */
+    limit?: number;
+}
+interface SessionSearchHit {
+    sessionId: string;
+    eventIndex: number;
+    ts: string;
+    type: SessionEventType;
+    /** Short snippet of the matched text — null for events without text content. */
+    snippet: string | null;
+}
+interface SessionSearchQuery {
+    /** Plain text or regex pattern. */
+    query: string;
+    /** Treat `query` as a regex. Defaults to false (literal substring). */
+    regex?: boolean;
+    /** Case-insensitive match. Defaults to true. */
+    caseInsensitive?: boolean;
+    /** Limit only to these event types. Defaults to all event types. */
+    types?: SessionEventType[];
+    /** Limit hit count. Defaults to 100. */
+    limit?: number;
+}
+interface SessionExportOptions {
+    /** "markdown" produces a human-readable chat log; "json" passes through raw events. */
+    format: 'markdown' | 'json' | 'text';
+    /** Include tool_use/tool_result blocks. Defaults to true. */
+    includeTools?: boolean;
+    /** Include system/diagnostic events (errors, compaction). Defaults to true. */
+    includeDiagnostics?: boolean;
+}
+interface SessionSummaryLite {
+    id: string;
+    title: string;
+    startedAt: string;
+    endedAt?: string;
+    provider: string;
+    model: string;
+    tokenTotal: number;
+}
+interface SessionReader {
+    /** List sessions matching the query. Uses the underlying store's summary cache. */
+    query(q?: SessionQuery): Promise<SessionSummaryLite[]>;
+    /** Yield events for `sessionId` in chronological order. */
+    replay(sessionId: string): AsyncIterable<SessionEvent>;
+    /** Full-text/regex search across one or all sessions. */
+    search(q: SessionSearchQuery, sessionId?: string): Promise<SessionSearchHit[]>;
+    /** Render a session for human or downstream-tool consumption. */
+    export(sessionId: string, opts: SessionExportOptions): Promise<string>;
+    /** Read the metadata header without loading the full event stream. */
+    metadata(sessionId: string): Promise<SessionMetadata>;
+}
+interface DefaultSessionReaderOptions {
+    store: SessionStore;
+}
+
+/**
+ * L2-A: read-only view over a `SessionStore` with query, replay, search,
+ * and export helpers. Implemented on top of the public `SessionStore`
+ * surface so any concrete store can be inspected without re-implementation.
+ *
+ * The heavy operations re-parse the JSONL stream on every call — fine for
+ * /resume and one-off analytics. Wrap with a memoizing decorator if needed.
+ */
+declare class DefaultSessionReader implements SessionReader {
+    private readonly store;
+    constructor(opts: DefaultSessionReaderOptions);
+    query(q?: SessionQuery): Promise<SessionSummaryLite[]>;
+    replay(sessionId: string): AsyncIterable<SessionEvent>;
+    search(q: SessionSearchQuery, sessionId?: string): Promise<SessionSearchHit[]>;
+    export(sessionId: string, opts: SessionExportOptions): Promise<string>;
+    metadata(sessionId: string): Promise<SessionMetadata>;
+}
+
+export { type AddAttachmentInput as A, DefaultSessionReader as D, type Attachment as a, type AttachmentKind as b, type AttachmentMeta as c, type AttachmentRef as d, type AttachmentStore as e };

package/dist/skill-Bx8jxznf.d.ts

@@ -0,0 +1,72 @@
+import { j as Response, a0 as Context, h as ProviderError } from './context-u0bryklF.js';
+
+type RecoveryDecision = {
+    /**
+     * Recovery mutated state or waited for capacity and the agent should
+     * rebuild the provider request and try the turn again.
+     */
+    action: 'retry';
+    reason: string;
+    model?: string;
+} | {
+    /**
+     * Recovery produced a substitute provider response that should be
+     * processed exactly like a normal model response.
+     */
+    action: 'continue';
+    response: Response;
+    reason?: string;
+} | {
+    /** Recovery inspected the error and decided the agent must fail. */
+    action: 'fail';
+    reason: string;
+    error?: unknown;
+};
+interface ErrorHandler {
+    /**
+     * Attempt to recover from an unretried provider/tool boundary error.
+     *
+     * `null` means "no strategy matched". Non-null decisions are explicit:
+     * retry the current turn, continue with a substitute response, or fail
+     * deliberately. Callers should not infer control flow from truthiness.
+     */
+    recover(err: unknown, ctx: Context): Promise<RecoveryDecision | null>;
+    classify(err: unknown): {
+        kind: 'rate_limit' | 'overloaded' | 'server' | 'client' | 'network' | 'abort' | 'context_overflow' | 'unknown';
+        retryable: boolean;
+    };
+}
+
+interface RetryPolicy {
+    shouldRetry(err: ProviderError | Error, attempt: number): boolean;
+    delayMs(attempt: number): number;
+    maxAttempts(err: ProviderError | Error): number;
+}
+
+interface SkillManifest {
+    name: string;
+    description: string;
+    version?: string;
+    path: string;
+    source: 'project' | 'user' | 'bundled';
+}
+/** Parsed skill entry for structured rendering in system prompt. */
+interface SkillEntry {
+    name: string;
+    /** "Use when..." trigger condition — one-liner */
+    trigger: string;
+    /** Comma-separated scope items */
+    scope: string[];
+    source: SkillManifest['source'];
+    path: string;
+}
+interface SkillLoader {
+    list(): Promise<SkillManifest[]>;
+    /** Structured entries with trigger/scope for system prompt rendering. */
+    listEntries(): Promise<SkillEntry[]>;
+    find(name: string): Promise<SkillManifest | undefined>;
+    manifestText(): Promise<string>;
+    readBody(name: string): Promise<string>;
+}
+
+export type { ErrorHandler as E, RecoveryDecision as R, SkillEntry as S, SkillLoader as a, SkillManifest as b, RetryPolicy as c };