@limo-labs/deity 0.1.0-alpha.0

package/dist/src/context/memory-view.js

@@ -0,0 +1,104 @@
+import { isStageVisible, isAccessAllowed } from "./context-scope.js";
+/**
+ * Memory view with access control based on context scope.
+ * Wraps TieredMemoryManager and enforces visibility rules.
+ */
+export class MemoryView {
+    memory;
+    scope;
+    constructor(memory, scope) {
+        this.memory = memory;
+        this.scope = scope;
+    }
+    /**
+     * Get a value from memory.
+     * Throws if the key's stage is not visible in this scope.
+     */
+    async get(key) {
+        this.checkAccess(key, "read");
+        return this.memory.get(key);
+    }
+    /**
+     * Set a value in memory.
+     * Throws if write access is not allowed or key's stage is not visible.
+     */
+    async set(key, value) {
+        this.checkAccess(key, "write");
+        await this.memory.set(key, value);
+    }
+    /**
+     * Check if a key exists in memory.
+     * Throws if the key's stage is not visible in this scope.
+     */
+    async has(key) {
+        this.checkAccess(key, "read");
+        return this.memory.has(key);
+    }
+    /**
+     * Delete a value from memory.
+     * Throws if write access is not allowed or key's stage is not visible.
+     */
+    async delete(key) {
+        this.checkAccess(key, "write");
+        await this.memory.delete(key);
+    }
+    /**
+     * Pin a key to prevent eviction.
+     * Throws if write access is not allowed or key's stage is not visible.
+     */
+    async pin(key) {
+        this.checkAccess(key, "write");
+        await this.memory.pin(key);
+    }
+    /**
+     * Unpin a key.
+     * Throws if write access is not allowed or key's stage is not visible.
+     */
+    unpin(key) {
+        this.checkAccess(key, "write");
+        this.memory.unpin(key);
+    }
+    /**
+     * Get the current scope.
+     */
+    getScope() {
+        return this.scope;
+    }
+    /**
+     * Check if access to a key is allowed in this scope.
+     * Throws AccessDeniedError if access is not allowed.
+     */
+    checkAccess(key, mode) {
+        // Extract stage ID from key (assumes format "stage:StageId")
+        const stageId = this.extractStageId(key);
+        // Check if stage is visible
+        if (!isStageVisible(this.scope, stageId)) {
+            throw new AccessDeniedError(`Access denied: stage "${stageId}" is not visible in scope "${this.scope.name}"`);
+        }
+        // Check if access mode is allowed
+        if (!isAccessAllowed(this.scope, mode)) {
+            throw new AccessDeniedError(`Access denied: ${mode} access not allowed in scope "${this.scope.name}"`);
+        }
+    }
+    /**
+     * Extract stage ID from a memory key.
+     * Assumes format "stage:StageId" or just "StageId".
+     */
+    extractStageId(key) {
+        if (key.startsWith("stage:")) {
+            return key.substring(6);
+        }
+        // If no prefix, assume the key itself is the stage ID
+        return key.split(":")[0];
+    }
+}
+/**
+ * Error thrown when access is denied due to scope restrictions.
+ */
+export class AccessDeniedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AccessDeniedError";
+    }
+}
+//# sourceMappingURL=memory-view.js.map

package/dist/src/context/memory-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-view.js","sourceRoot":"","sources":["../../../src/context/memory-view.ts"],"names":[],"mappings":"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"}

package/dist/src/context/scoped-context.d.ts

@@ -0,0 +1,51 @@
+import type { ExecutionContext } from "../stage.js";
+import type { StateStore } from "../store.js";
+import type { TraceLogger } from "../trace.js";
+import { MemoryView } from "./memory-view.js";
+import type { ContextScope } from "./context-scope.js";
+/**
+ * Scoped execution context with memory access control.
+ * Implements the ExecutionContext interface with visibility restrictions.
+ */
+export declare class ScopedExecutionContext<I = unknown> implements ExecutionContext<I> {
+    /** Input to the current stage */
+    inputs: I;
+    /** Memory view with access control */
+    memory: MemoryView;
+    /** Scope defining visibility rules */
+    scope: ContextScope;
+    /** Parent context (if this is a child context) */
+    parent?: ScopedExecutionContext<any>;
+    /** Legacy store access (read-only) */
+    store: StateStore;
+    /** Legacy trace logger */
+    trace: TraceLogger;
+    constructor(config: {
+        inputs: I;
+        memory: MemoryView;
+        scope: ContextScope;
+        parent?: ScopedExecutionContext<any>;
+        store: StateStore;
+        trace: TraceLogger;
+    });
+    /**
+     * Get previous outputs (legacy interface).
+     * Returns all visible stage outputs.
+     */
+    get previousOutputs(): Record<string, unknown>;
+    /**
+     * Get output from a specific stage (legacy interface).
+     * Uses memory view with access control.
+     */
+    getOutput<T>(stageId: string): T;
+    /**
+     * Create a child context with a different scope.
+     * Inherits inputs and memory but with restricted visibility.
+     */
+    createChild(childScope: ContextScope): ScopedExecutionContext<I>;
+    /**
+     * Create an isolated child context that can only see specific stages.
+     */
+    isolate(visibleStages: string[]): ScopedExecutionContext<I>;
+}
+//# sourceMappingURL=scoped-context.d.ts.map

package/dist/src/context/scoped-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-context.d.ts","sourceRoot":"","sources":["../../../src/context/scoped-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,qBAAa,sBAAsB,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;IAC7E,iCAAiC;IACjC,MAAM,EAAE,CAAC,CAAC;IAEV,sCAAsC;IACtC,MAAM,EAAE,UAAU,CAAC;IAEnB,sCAAsC;IACtC,KAAK,EAAE,YAAY,CAAC;IAEpB,kDAAkD;IAClD,MAAM,CAAC,EAAE,sBAAsB,CAAC,GAAG,CAAC,CAAC;IAErC,sCAAsC;IACtC,KAAK,EAAE,UAAU,CAAC;IAElB,0BAA0B;IAC1B,KAAK,EAAE,WAAW,CAAC;gBAEP,MAAM,EAAE;QAClB,MAAM,EAAE,CAAC,CAAC;QACV,MAAM,EAAE,UAAU,CAAC;QACnB,KAAK,EAAE,YAAY,CAAC;QACpB,MAAM,CAAC,EAAE,sBAAsB,CAAC,GAAG,CAAC,CAAC;QACrC,KAAK,EAAE,UAAU,CAAC;QAClB,KAAK,EAAE,WAAW,CAAC;KACpB;IASD;;;OAGG;IACH,IAAI,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAI7C;IAED;;;OAGG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC;IAQhC;;;OAGG;IACH,WAAW,CAAC,UAAU,EAAE,YAAY,GAAG,sBAAsB,CAAC,CAAC,CAAC;IAiBhE;;OAEG;IACH,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,sBAAsB,CAAC,CAAC,CAAC;CAS5D"}

package/dist/src/context/scoped-context.js

@@ -0,0 +1,74 @@
+import { MemoryView } from "./memory-view.js";
+/**
+ * Scoped execution context with memory access control.
+ * Implements the ExecutionContext interface with visibility restrictions.
+ */
+export class ScopedExecutionContext {
+    /** Input to the current stage */
+    inputs;
+    /** Memory view with access control */
+    memory;
+    /** Scope defining visibility rules */
+    scope;
+    /** Parent context (if this is a child context) */
+    parent;
+    /** Legacy store access (read-only) */
+    store;
+    /** Legacy trace logger */
+    trace;
+    constructor(config) {
+        this.inputs = config.inputs;
+        this.memory = config.memory;
+        this.scope = config.scope;
+        this.parent = config.parent;
+        this.store = config.store;
+        this.trace = config.trace;
+    }
+    /**
+     * Get previous outputs (legacy interface).
+     * Returns all visible stage outputs.
+     */
+    get previousOutputs() {
+        // This would need to be populated from memory
+        // For now, return empty object (handled by memory view)
+        return {};
+    }
+    /**
+     * Get output from a specific stage (legacy interface).
+     * Uses memory view with access control.
+     */
+    getOutput(stageId) {
+        // Synchronous wrapper - in real usage, this would need to be async
+        // For POC, we'll throw if not found
+        throw new Error(`getOutput is synchronous but memory is async. Use memory.get("stage:${stageId}") instead.`);
+    }
+    /**
+     * Create a child context with a different scope.
+     * Inherits inputs and memory but with restricted visibility.
+     */
+    createChild(childScope) {
+        // Create new memory view with child scope
+        const childMemory = new MemoryView(this.memory.memory, // Access underlying tiered memory
+        childScope);
+        return new ScopedExecutionContext({
+            inputs: this.inputs,
+            memory: childMemory,
+            scope: childScope,
+            parent: this,
+            store: this.store,
+            trace: this.trace,
+        });
+    }
+    /**
+     * Create an isolated child context that can only see specific stages.
+     */
+    isolate(visibleStages) {
+        const isolatedScope = {
+            name: `isolated(${visibleStages.join(",")})`,
+            visibleStages,
+            canWrite: true,
+        };
+        return this.createChild(isolatedScope);
+    }
+}
+//# sourceMappingURL=scoped-context.js.map

package/dist/src/context/scoped-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-context.js","sourceRoot":"","sources":["../../../src/context/scoped-context.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C;;;GAGG;AACH,MAAM,OAAO,sBAAsB;IACjC,iCAAiC;IACjC,MAAM,CAAI;IAEV,sCAAsC;IACtC,MAAM,CAAa;IAEnB,sCAAsC;IACtC,KAAK,CAAe;IAEpB,kDAAkD;IAClD,MAAM,CAA+B;IAErC,sCAAsC;IACtC,KAAK,CAAa;IAElB,0BAA0B;IAC1B,KAAK,CAAc;IAEnB,YAAY,MAOX;QACC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,IAAI,eAAe;QACjB,8CAA8C;QAC9C,wDAAwD;QACxD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;OAGG;IACH,SAAS,CAAI,OAAe;QAC1B,mEAAmE;QACnE,oCAAoC;QACpC,MAAM,IAAI,KAAK,CACb,uEAAuE,OAAO,aAAa,CAC5F,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,UAAwB;QAClC,0CAA0C;QAC1C,MAAM,WAAW,GAAG,IAAI,UAAU,CAC/B,IAAI,CAAC,MAAc,CAAC,MAAM,EAAE,kCAAkC;QAC/D,UAAU,CACX,CAAC;QAEF,OAAO,IAAI,sBAAsB,CAAC;YAChC,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,MAAM,EAAE,WAAW;YACnB,KAAK,EAAE,UAAU;YACjB,MAAM,EAAE,IAAI;YACZ,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,aAAuB;QAC7B,MAAM,aAAa,GAAiB;YAClC,IAAI,EAAE,YAAY,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG;YAC5C,aAAa;YACb,QAAQ,EAAE,IAAI;SACf,CAAC;QAEF,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACzC,CAAC;CACF"}

package/dist/src/context/scoped-execution-context.d.ts

@@ -0,0 +1,55 @@
+import type { ExecutionContext } from "../stage.js";
+import type { StateStore } from "../store.js";
+import type { TraceLogger } from "../trace.js";
+import type { ConversationManager } from "../conversation/conversation-manager.js";
+import { MemoryView } from "./memory-view.js";
+import type { ContextScope } from "./context-scope.js";
+/**
+ * Scoped execution context with memory access control.
+ * Implements the ExecutionContext interface with visibility restrictions.
+ */
+export declare class ScopedExecutionContext<I = unknown> implements ExecutionContext<I> {
+    /** Input to the current stage */
+    inputs: I;
+    /** Memory view with access control */
+    memory: MemoryView;
+    /** Scope defining visibility rules */
+    scope: ContextScope;
+    /** Parent context (if this is a child context) */
+    parent?: ScopedExecutionContext<any>;
+    /** Legacy store access (read-only) */
+    store: StateStore;
+    /** Legacy trace logger */
+    trace: TraceLogger;
+    /** Conversation history manager */
+    conversation: ConversationManager;
+    constructor(config: {
+        inputs: I;
+        memory: MemoryView;
+        scope: ContextScope;
+        parent?: ScopedExecutionContext<any>;
+        store: StateStore;
+        trace: TraceLogger;
+        conversation: ConversationManager;
+    });
+    /**
+     * Get previous outputs (legacy interface).
+     * Returns all visible stage outputs.
+     */
+    get previousOutputs(): Record<string, unknown>;
+    /**
+     * Get output from a specific stage (legacy interface).
+     * Uses memory view with access control.
+     */
+    getOutput<T>(stageId: string): T;
+    /**
+     * Create a child context with a different scope.
+     * Inherits inputs and memory but with restricted visibility.
+     */
+    createChild(childScope: ContextScope): ScopedExecutionContext<I>;
+    /**
+     * Create an isolated child context that can only see specific stages.
+     */
+    isolate(visibleStages: string[]): ScopedExecutionContext<I>;
+}
+//# sourceMappingURL=scoped-execution-context.d.ts.map

package/dist/src/context/scoped-execution-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-execution-context.d.ts","sourceRoot":"","sources":["../../../src/context/scoped-execution-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;GAGG;AACH,qBAAa,sBAAsB,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;IAC7E,iCAAiC;IACjC,MAAM,EAAE,CAAC,CAAC;IAEV,sCAAsC;IACtC,MAAM,EAAE,UAAU,CAAC;IAEnB,sCAAsC;IACtC,KAAK,EAAE,YAAY,CAAC;IAEpB,kDAAkD;IAClD,MAAM,CAAC,EAAE,sBAAsB,CAAC,GAAG,CAAC,CAAC;IAErC,sCAAsC;IACtC,KAAK,EAAE,UAAU,CAAC;IAElB,0BAA0B;IAC1B,KAAK,EAAE,WAAW,CAAC;IAEnB,mCAAmC;IACnC,YAAY,EAAE,mBAAmB,CAAC;gBAEtB,MAAM,EAAE;QAClB,MAAM,EAAE,CAAC,CAAC;QACV,MAAM,EAAE,UAAU,CAAC;QACnB,KAAK,EAAE,YAAY,CAAC;QACpB,MAAM,CAAC,EAAE,sBAAsB,CAAC,GAAG,CAAC,CAAC;QACrC,KAAK,EAAE,UAAU,CAAC;QAClB,KAAK,EAAE,WAAW,CAAC;QACnB,YAAY,EAAE,mBAAmB,CAAC;KACnC;IAUD;;;OAGG;IACH,IAAI,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAI7C;IAED;;;OAGG;IACH,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC;IAQhC;;;OAGG;IACH,WAAW,CAAC,UAAU,EAAE,YAAY,GAAG,sBAAsB,CAAC,CAAC,CAAC;IAkBhE;;OAEG;IACH,OAAO,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,sBAAsB,CAAC,CAAC,CAAC;CAS5D"}

package/dist/src/context/scoped-execution-context.js

@@ -0,0 +1,78 @@
+import { MemoryView } from "./memory-view.js";
+/**
+ * Scoped execution context with memory access control.
+ * Implements the ExecutionContext interface with visibility restrictions.
+ */
+export class ScopedExecutionContext {
+    /** Input to the current stage */
+    inputs;
+    /** Memory view with access control */
+    memory;
+    /** Scope defining visibility rules */
+    scope;
+    /** Parent context (if this is a child context) */
+    parent;
+    /** Legacy store access (read-only) */
+    store;
+    /** Legacy trace logger */
+    trace;
+    /** Conversation history manager */
+    conversation;
+    constructor(config) {
+        this.inputs = config.inputs;
+        this.memory = config.memory;
+        this.scope = config.scope;
+        this.parent = config.parent;
+        this.store = config.store;
+        this.trace = config.trace;
+        this.conversation = config.conversation;
+    }
+    /**
+     * Get previous outputs (legacy interface).
+     * Returns all visible stage outputs.
+     */
+    get previousOutputs() {
+        // This would need to be populated from memory
+        // For now, return empty object (handled by memory view)
+        return {};
+    }
+    /**
+     * Get output from a specific stage (legacy interface).
+     * Uses memory view with access control.
+     */
+    getOutput(stageId) {
+        // Synchronous wrapper - in real usage, this would need to be async
+        // For POC, we'll throw if not found
+        throw new Error(`getOutput is synchronous but memory is async. Use memory.get("stage:${stageId}") instead.`);
+    }
+    /**
+     * Create a child context with a different scope.
+     * Inherits inputs and memory but with restricted visibility.
+     */
+    createChild(childScope) {
+        // Create new memory view with child scope
+        const childMemory = new MemoryView(this.memory.memory, // Access underlying tiered memory
+        childScope);
+        return new ScopedExecutionContext({
+            inputs: this.inputs,
+            memory: childMemory,
+            scope: childScope,
+            parent: this,
+            store: this.store,
+            trace: this.trace,
+            conversation: this.conversation,
+        });
+    }
+    /**
+     * Create an isolated child context that can only see specific stages.
+     */
+    isolate(visibleStages) {
+        const isolatedScope = {
+            name: `isolated(${visibleStages.join(",")})`,
+            visibleStages,
+            canWrite: true,
+        };
+        return this.createChild(isolatedScope);
+    }
+}
+//# sourceMappingURL=scoped-execution-context.js.map

package/dist/src/context/scoped-execution-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-execution-context.js","sourceRoot":"","sources":["../../../src/context/scoped-execution-context.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C;;;GAGG;AACH,MAAM,OAAO,sBAAsB;IACjC,iCAAiC;IACjC,MAAM,CAAI;IAEV,sCAAsC;IACtC,MAAM,CAAa;IAEnB,sCAAsC;IACtC,KAAK,CAAe;IAEpB,kDAAkD;IAClD,MAAM,CAA+B;IAErC,sCAAsC;IACtC,KAAK,CAAa;IAElB,0BAA0B;IAC1B,KAAK,CAAc;IAEnB,mCAAmC;IACnC,YAAY,CAAsB;IAElC,YAAY,MAQX;QACC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,IAAI,eAAe;QACjB,8CAA8C;QAC9C,wDAAwD;QACxD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED;;;OAGG;IACH,SAAS,CAAI,OAAe;QAC1B,mEAAmE;QACnE,oCAAoC;QACpC,MAAM,IAAI,KAAK,CACb,uEAAuE,OAAO,aAAa,CAC5F,CAAC;IACJ,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,UAAwB;QAClC,0CAA0C;QAC1C,MAAM,WAAW,GAAG,IAAI,UAAU,CAC/B,IAAI,CAAC,MAAc,CAAC,MAAM,EAAE,kCAAkC;QAC/D,UAAU,CACX,CAAC;QAEF,OAAO,IAAI,sBAAsB,CAAC;YAChC,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,MAAM,EAAE,WAAW;YACnB,KAAK,EAAE,UAAU;YACjB,MAAM,EAAE,IAAI;YACZ,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,YAAY,EAAE,IAAI,CAAC,YAAY;SAChC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,aAAuB;QAC7B,MAAM,aAAa,GAAiB;YAClC,IAAI,EAAE,YAAY,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG;YAC5C,aAAa;YACb,QAAQ,EAAE,IAAI;SACf,CAAC;QAEF,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;IACzC,CAAC;CACF"}

package/dist/src/conversation/conversation-manager.d.ts

@@ -0,0 +1,272 @@
+/**
+ * Conversation history management for long-running AI agents.
+ *
+ * This module provides interfaces for managing conversation history,
+ * including message storage, pruning strategies, and export/import functionality.
+ *
+ * @module conversation
+ * @since 2.0.0
+ */
+import type { Message } from "../component.js";
+/**
+ * Metadata attached to each message in the conversation history.
+ *
+ * @since 2.0.0
+ */
+export interface MessageMetadata {
+    /** Unique identifier for this message */
+    id: string;
+    /** Timestamp when the message was added */
+    timestamp: number;
+    /** Optional stage ID that generated this message */
+    stageId?: string;
+    /** Optional token count for the message */
+    tokens?: number;
+    /** Whether this message is marked as important (won't be pruned easily) */
+    important?: boolean;
+    /** Custom metadata for application-specific use */
+    custom?: Record<string, unknown>;
+}
+/**
+ * A message with its associated metadata.
+ *
+ * @since 2.0.0
+ */
+export interface ConversationMessage {
+    /** The actual message content */
+    message: Message;
+    /** Metadata about this message */
+    metadata: MessageMetadata;
+}
+/**
+ * Strategy for pruning old messages from conversation history.
+ *
+ * Multiple strategies can be combined - messages are kept if they match ANY strategy.
+ *
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // Keep last 100 messages
+ * const strategy: PruneStrategy = {
+ *   keepRecent: 100
+ * };
+ *
+ * // Keep messages less than 1 hour old
+ * const strategy: PruneStrategy = {
+ *   maxAge: 60 * 60 * 1000 // 1 hour in milliseconds
+ * };
+ *
+ * // Keep important messages and last 50
+ * const strategy: PruneStrategy = {
+ *   keepRecent: 50,
+ *   keepImportant: (msg) => msg.metadata.important === true
+ * };
+ *
+ * // Custom strategy based on token count
+ * const strategy: PruneStrategy = {
+ *   keepRecent: 10,
+ *   keepImportant: (msg) => (msg.metadata.tokens ?? 0) > 1000
+ * };
+ * ```
+ */
+export interface PruneStrategy {
+    /**
+     * Keep the most recent N messages.
+     * These messages will never be pruned regardless of age.
+     */
+    keepRecent?: number;
+    /**
+     * Function to determine if a message is important.
+     * Important messages are kept regardless of age or position.
+     *
+     * @param message - The conversation message to check
+     * @returns true if the message should be kept, false otherwise
+     */
+    keepImportant?: (message: ConversationMessage) => boolean;
+    /**
+     * Maximum age of messages to keep (in milliseconds).
+     * Messages older than this will be pruned unless they match other keep criteria.
+     */
+    maxAge?: number;
+}
+/**
+ * Statistics about the current conversation state.
+ *
+ * @since 2.0.0
+ */
+export interface ConversationStats {
+    /** Total number of messages in the conversation */
+    messageCount: number;
+    /** Number of messages by role */
+    byRole: Record<string, number>;
+    /** Total estimated token count (if available) */
+    totalTokens?: number;
+    /** Timestamp of oldest message */
+    oldestMessage?: number;
+    /** Timestamp of newest message */
+    newestMessage?: number;
+}
+/**
+ * Snapshot of conversation history for export/import.
+ *
+ * This format is designed to be JSON-serializable for easy persistence.
+ *
+ * @since 2.0.0
+ */
+export interface ConversationSnapshot {
+    /** Version of the snapshot format for future compatibility */
+    version: string;
+    /** Timestamp when the snapshot was created */
+    createdAt: number;
+    /** All messages in the conversation */
+    messages: ConversationMessage[];
+    /** Optional metadata about the conversation */
+    metadata?: {
+        /** Name or description of the conversation */
+        name?: string;
+        /** Tags or labels for categorization */
+        tags?: string[];
+        /** Custom application-specific data */
+        custom?: Record<string, unknown>;
+    };
+}
+/**
+ * Query parameters for searching conversation history.
+ *
+ * @since 2.0.0
+ */
+export interface ConversationQuery {
+    /** Filter by message role (system, user, assistant, tool) */
+    role?: string;
+    /** Search for messages containing this text (case-insensitive) */
+    content?: string;
+    /** Filter by stage ID */
+    stageId?: string;
+    /** Filter by timestamp range */
+    after?: number;
+    before?: number;
+    /** Filter by importance flag */
+    important?: boolean;
+    /** Limit number of results */
+    limit?: number;
+}
+/**
+ * Main interface for managing conversation history.
+ *
+ * Implementations should be thread-safe and handle concurrent access.
+ *
+ * @since 2.0.0
+ *
+ * @example
+ * ```typescript
+ * // Create a conversation manager
+ * const conversation = new InMemoryConversationManager();
+ *
+ * // Add messages
+ * await conversation.addMessage({
+ *   role: "user",
+ *   content: "Hello!"
+ * });
+ *
+ * await conversation.addMessage({
+ *   role: "assistant",
+ *   content: "Hi! How can I help?"
+ * });
+ *
+ * // Get recent messages
+ * const recent = await conversation.getRecent(10);
+ *
+ * // Search for specific messages
+ * const userMessages = await conversation.search({ role: "user" });
+ *
+ * // Prune old messages
+ * await conversation.prune({
+ *   keepRecent: 100,
+ *   maxAge: 24 * 60 * 60 * 1000 // 24 hours
+ * });
+ *
+ * // Export for persistence
+ * const snapshot = await conversation.export();
+ * await fs.writeFile("conversation.json", JSON.stringify(snapshot));
+ *
+ * // Import later
+ * const loaded = JSON.parse(await fs.readFile("conversation.json"));
+ * await conversation.import(loaded);
+ * ```
+ */
+export interface ConversationManager {
+    /**
+     * Add a new message to the conversation history.
+     *
+     * The message will be assigned a unique ID and timestamp automatically.
+     *
+     * @param message - The message to add
+     * @param metadata - Optional metadata (id and timestamp will be auto-generated if not provided)
+     * @returns Promise that resolves when the message is added
+     */
+    addMessage(message: Message, metadata?: Partial<Omit<MessageMetadata, "id" | "timestamp">>): Promise<void>;
+    /**
+     * Get the complete conversation history.
+     *
+     * @returns Promise that resolves to all messages in chronological order
+     */
+    getHistory(): Promise<ConversationMessage[]>;
+    /**
+     * Get the most recent N messages.
+     *
+     * @param count - Number of messages to retrieve
+     * @returns Promise that resolves to the most recent messages in chronological order
+     */
+    getRecent(count: number): Promise<ConversationMessage[]>;
+    /**
+     * Search for messages matching the query criteria.
+     *
+     * @param query - Search parameters
+     * @returns Promise that resolves to matching messages in chronological order
+     */
+    search(query: ConversationQuery): Promise<ConversationMessage[]>;
+    /**
+     * Remove old or unimportant messages based on the pruning strategy.
+     *
+     * Messages are kept if they match ANY of the keep criteria:
+     * - Among the most recent N messages (keepRecent)
+     * - Marked as important (keepImportant returns true)
+     * - Within the max age threshold (maxAge)
+     *
+     * @param strategy - Strategy for determining which messages to keep
+     * @returns Promise that resolves to the number of messages pruned
+     */
+    prune(strategy: PruneStrategy): Promise<number>;
+    /**
+     * Clear all messages from the conversation.
+     *
+     * @returns Promise that resolves when the conversation is cleared
+     */
+    clear(): Promise<void>;
+    /**
+     * Get statistics about the current conversation.
+     *
+     * @returns Promise that resolves to conversation statistics
+     */
+    getStats(): Promise<ConversationStats>;
+    /**
+     * Export the conversation to a snapshot for persistence.
+     *
+     * The snapshot is a plain JavaScript object that can be JSON-serialized.
+     *
+     * @returns Promise that resolves to a conversation snapshot
+     */
+    export(): Promise<ConversationSnapshot>;
+    /**
+     * Import a conversation from a snapshot.
+     *
+     * This will replace the current conversation with the imported one.
+     * Use with caution - consider backing up the current conversation first.
+     *
+     * @param snapshot - The conversation snapshot to import
+     * @returns Promise that resolves when the import is complete
+     */
+    import(snapshot: ConversationSnapshot): Promise<void>;
+}
+//# sourceMappingURL=conversation-manager.d.ts.map

package/dist/src/conversation/conversation-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation-manager.d.ts","sourceRoot":"","sources":["../../../src/conversation/conversation-manager.ts"],"names":[],"mappings":"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"}

package/dist/src/conversation/conversation-manager.js

@@ -0,0 +1,11 @@
+/**
+ * Conversation history management for long-running AI agents.
+ *
+ * This module provides interfaces for managing conversation history,
+ * including message storage, pruning strategies, and export/import functionality.
+ *
+ * @module conversation
+ * @since 2.0.0
+ */
+export {};
+//# sourceMappingURL=conversation-manager.js.map