@olane/o-lane 0.7.12-alpha.76 → 0.7.12

package/dist/src/storage/prompt-seeder.js

@@ -0,0 +1,141 @@
+/**
+ * Prompt Seeder
+ *
+ * Seeds the PromptStorageProvider with prompt templates from prompts/ folder
+ */
+import { PROMPT_KEYS, PROMPT_IDS, PROMPT_VERSION, } from './prompt-schema.js';
+import { BASE_TEMPLATE_SEED } from '../prompts/custom.prompt.js';
+import { CYCLE_INSTRUCTIONS_SEED, OUTPUT_INSTRUCTIONS_SEED, } from '../prompts/agent.prompt.js';
+import { CONFIGURE_INSTRUCTIONS_SEED } from '../prompts/configure.prompt.js';
+/**
+ * Seeds the prompt storage with default prompt templates
+ */
+export class PromptSeeder {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Seed all default prompts into storage
+     */
+    async seedAll() {
+        await this.seedBaseTemplate();
+        await this.seedCycleInstructions();
+        await this.seedOutputInstructions();
+        await this.seedConfigureInstructions();
+    }
+    /**
+     * Seed the base template from custom.prompt.ts
+     */
+    async seedBaseTemplate() {
+        const template = {
+            content: BASE_TEMPLATE_SEED,
+            metadata: {
+                version: PROMPT_VERSION,
+                description: 'Base agent prompt template structure',
+                lastModified: Date.now(),
+                source: 'prompts/custom.prompt.ts (BASE_TEMPLATE_SEED)',
+            },
+        };
+        await this.storage.use(this.storage.address, {
+            method: 'put',
+            params: {
+                promptId: PROMPT_IDS.AGENT,
+                key: PROMPT_KEYS.BASE_TEMPLATE,
+                value: template,
+            },
+        });
+    }
+    /**
+     * Seed cycle instructions from agent.prompt.ts
+     */
+    async seedCycleInstructions() {
+        const template = {
+            content: CYCLE_INSTRUCTIONS_SEED,
+            metadata: {
+                version: PROMPT_VERSION,
+                description: 'Agent cycle workflow instructions (6 steps)',
+                lastModified: Date.now(),
+                source: 'prompts/agent.prompt.ts (CYCLE_INSTRUCTIONS_SEED)',
+            },
+        };
+        await this.storage.use(this.storage.address, {
+            method: 'put',
+            params: {
+                promptId: PROMPT_IDS.AGENT,
+                key: PROMPT_KEYS.CYCLE_INSTRUCTIONS,
+                value: template,
+            },
+        });
+    }
+    /**
+     * Seed output instructions from agent.prompt.ts
+     */
+    async seedOutputInstructions() {
+        const template = {
+            content: OUTPUT_INSTRUCTIONS_SEED,
+            metadata: {
+                version: PROMPT_VERSION,
+                description: 'Agent return format instructions',
+                lastModified: Date.now(),
+                source: 'prompts/agent.prompt.ts (OUTPUT_INSTRUCTIONS_SEED)',
+            },
+        };
+        await this.storage.use(this.storage.address, {
+            method: 'put',
+            params: {
+                promptId: PROMPT_IDS.AGENT,
+                key: PROMPT_KEYS.OUTPUT_INSTRUCTIONS,
+                value: template,
+            },
+        });
+    }
+    /**
+     * Seed configure instructions from configure.prompt.ts
+     */
+    async seedConfigureInstructions() {
+        const template = {
+            content: CONFIGURE_INSTRUCTIONS_SEED,
+            metadata: {
+                version: PROMPT_VERSION,
+                description: 'Configure capability specific instructions',
+                lastModified: Date.now(),
+                source: 'prompts/configure.prompt.ts (CONFIGURE_INSTRUCTIONS_SEED)',
+            },
+        };
+        await this.storage.use(this.storage.address, {
+            method: 'put',
+            params: {
+                promptId: PROMPT_IDS.AGENT,
+                key: PROMPT_KEYS.CONFIGURE_INSTRUCTIONS,
+                value: template,
+            },
+        });
+    }
+    /**
+     * Check if prompts are already seeded
+     */
+    async isSeeded() {
+        const response = await this.storage.use(this.storage.address, {
+            method: 'has',
+            params: {
+                promptId: PROMPT_IDS.AGENT,
+                key: PROMPT_KEYS.BASE_TEMPLATE,
+            },
+        });
+        if (!response.result.success) {
+            return false;
+        }
+        return response.result?.data?.exists === true;
+    }
+    /**
+     * Clear all seeded prompts
+     */
+    async clearAll() {
+        await this.storage.use(this.storage.address, {
+            method: 'clear_prompt',
+            params: {
+                promptId: PROMPT_IDS.AGENT,
+            },
+        });
+    }
+}

package/dist/src/storage/prompt-storage-provider.tool.d.ts

@@ -0,0 +1,99 @@
+import { ToolResult } from '@olane/o-tool';
+import { StorageProviderTool } from '@olane/o-storage';
+import { oRequest } from '@olane/o-core';
+import { GetDataResponse } from '@olane/o-storage';
+import { PromptStorageConfig, PromptStats, ListPromptsResponse, PromptKeysResponse, ClearPromptResponse } from './interfaces/prompt-storage.interface.js';
+import { oNodeAddress } from '@olane/o-node';
+/**
+ * Prompt-specific storage provider that isolates data per prompt/conversation
+ * Extends StorageProviderTool to provide namespace isolation by promptId
+ *
+ * Features:
+ * - Isolated storage namespaces per promptId
+ * - Standard CRUD operations (put, get, delete, has)
+ * - Prompt management (list, clear, stats)
+ * - Optional TTL-based cleanup for inactive prompts
+ * - Memory-efficient nested Map structure
+ */
+export declare class PromptStorageProvider extends StorageProviderTool {
+    readonly config: PromptStorageConfig;
+    /**
+     * Node address (inherited from base class)
+     */
+    readonly address: oNodeAddress;
+    /**
+     * Nested storage: Map<promptId, Map<key, value>>
+     * Provides O(1) access with automatic namespace isolation
+     */
+    private storage;
+    /**
+     * Metadata tracking per prompt for stats and cleanup
+     */
+    private metadata;
+    /**
+     * Cleanup interval timer
+     */
+    private cleanupTimer?;
+    constructor(config: PromptStorageConfig);
+    /**
+     * Initialize background cleanup task if TTL is configured
+     */
+    hookStartFinished(): Promise<void>;
+    /**
+     * Store data in a prompt-specific namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data (base class wraps it)
+     */
+    _tool_put(request: oRequest): Promise<ToolResult>;
+    /**
+     * Retrieve data from a prompt-specific namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data with null for missing keys
+     */
+    _tool_get(request: oRequest): Promise<GetDataResponse>;
+    /**
+     * Delete a specific key from a prompt namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data
+     */
+    _tool_delete(request: oRequest): Promise<ToolResult>;
+    /**
+     * Check if a key exists in a prompt namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data
+     */
+    _tool_has(request: oRequest): Promise<ToolResult>;
+    /**
+     * List all prompt IDs with active storage
+     */
+    _tool_list_prompts(_request: oRequest): Promise<ListPromptsResponse>;
+    /**
+     * Clear all data for a specific prompt namespace
+     */
+    _tool_clear_prompt(request: oRequest): Promise<ClearPromptResponse>;
+    /**
+     * Get all keys stored in a specific prompt namespace
+     */
+    _tool_get_prompt_keys(request: oRequest): Promise<PromptKeysResponse>;
+    /**
+     * Get statistics for a specific prompt namespace
+     */
+    _tool_get_prompt_stats(request: oRequest): Promise<PromptStats>;
+    /**
+     * Cleanup resources on stop
+     */
+    stop(): Promise<void>;
+    /**
+     * Update last accessed timestamp for a prompt
+     */
+    private updateLastAccessed;
+    /**
+     * Clean up prompts that haven't been accessed within TTL
+     */
+    private cleanupExpiredPrompts;
+    /**
+     * Evict the oldest prompt when max limit is reached
+     */
+    private evictOldestPrompt;
+}
+//# sourceMappingURL=prompt-storage-provider.tool.d.ts.map

package/dist/src/storage/prompt-storage-provider.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-storage-provider.tool.d.ts","sourceRoot":"","sources":["../../../src/storage/prompt-storage-provider.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnD,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,qBAAa,qBAAsB,SAAQ,mBAAmB;IAuBhD,QAAQ,CAAC,MAAM,EAAE,mBAAmB;IAtBhD;;OAEG;IACH,SAAgB,OAAO,EAAG,YAAY,CAAC;IAEvC;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAmC;IAElD;;OAEG;IACH,OAAO,CAAC,QAAQ,CAA8B;IAG9C;;OAEG;IACH,OAAO,CAAC,YAAY,CAAC,CAAiB;gBAEjB,MAAM,EAAE,mBAAmB;IAgBhD;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBxC;;;;OAIG;IACG,SAAS,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAwCvD;;;;OAIG;IACG,SAAS,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,eAAe,CAAC;IA+B5D;;;;OAIG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAoC1D;;;;OAIG;IACG,SAAS,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAyBvD;;OAEG;IACG,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAS1E;;OAEG;IACG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA4BzE;;OAEG;IACG,qBAAqB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAyB3E;;OAEG;IACG,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC;IA+BrE;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAyB7B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAqB1B"}

package/dist/src/storage/prompt-storage-provider.tool.js

@@ -0,0 +1,320 @@
+import { StorageProviderTool } from '@olane/o-storage';
+import { oAddress } from '@olane/o-core';
+import { PROMPT_STORAGE_METHODS } from './methods/prompt-storage.methods.js';
+/**
+ * Prompt-specific storage provider that isolates data per prompt/conversation
+ * Extends StorageProviderTool to provide namespace isolation by promptId
+ *
+ * Features:
+ * - Isolated storage namespaces per promptId
+ * - Standard CRUD operations (put, get, delete, has)
+ * - Prompt management (list, clear, stats)
+ * - Optional TTL-based cleanup for inactive prompts
+ * - Memory-efficient nested Map structure
+ */
+export class PromptStorageProvider extends StorageProviderTool {
+    constructor(config) {
+        const finalConfig = {
+            ...config,
+            address: config.address || new oAddress('o://prompt-storage'),
+            methods: PROMPT_STORAGE_METHODS,
+            description: 'Prompt-specific storage provider with isolated namespaces per conversation',
+        };
+        super(finalConfig);
+        this.config = config;
+        this.config = finalConfig;
+        this.storage = new Map();
+        this.metadata = new Map();
+    }
+    /**
+     * Initialize background cleanup task if TTL is configured
+     */
+    async hookStartFinished() {
+        if (this.config.promptTTL) {
+            const interval = this.config.cleanupInterval || 60000; // Default 1 minute
+            this.cleanupTimer = setInterval(() => {
+                this.cleanupExpiredPrompts();
+            }, interval);
+            this.logger.info('Prompt storage cleanup enabled', {
+                ttl: this.config.promptTTL,
+                interval,
+            });
+        }
+        await super.hookStartFinished();
+    }
+    /**
+     * Store data in a prompt-specific namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data (base class wraps it)
+     */
+    async _tool_put(request) {
+        const { promptId, key, value } = request.params;
+        // Validate required parameters
+        if (!promptId || typeof promptId !== 'string') {
+            throw new Error('promptId is required and must be a string');
+        }
+        if (!key || typeof key !== 'string') {
+            throw new Error('key is required and must be a string');
+        }
+        if (value === undefined || value === null) {
+            throw new Error('value is required');
+        }
+        // Ensure prompt namespace exists
+        if (!this.storage.has(promptId)) {
+            this.storage.set(promptId, new Map());
+            this.metadata.set(promptId, {
+                createdAt: Date.now(),
+                lastAccessed: Date.now(),
+            });
+        }
+        // Store value and update metadata
+        const promptStorage = this.storage.get(promptId);
+        promptStorage.set(key, String(value));
+        this.updateLastAccessed(promptId);
+        // Check max prompts limit
+        if (this.config.maxPrompts && this.storage.size > this.config.maxPrompts) {
+            this.evictOldestPrompt();
+        }
+        return {
+            success: true,
+        };
+    }
+    /**
+     * Retrieve data from a prompt-specific namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data with null for missing keys
+     */
+    async _tool_get(request) {
+        const { promptId, key } = request.params;
+        // Validate required parameters
+        if (!promptId || typeof promptId !== 'string') {
+            throw new Error('promptId is required and must be a string');
+        }
+        if (!key || typeof key !== 'string') {
+            throw new Error('key is required and must be a string');
+        }
+        // Check if prompt exists
+        const promptStorage = this.storage.get(promptId);
+        if (!promptStorage) {
+            return {
+                value: null,
+            };
+        }
+        // Get value and update metadata
+        const value = promptStorage.get(key);
+        if (value !== undefined) {
+            this.updateLastAccessed(promptId);
+        }
+        return {
+            value: value ?? null,
+        };
+    }
+    /**
+     * Delete a specific key from a prompt namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data
+     */
+    async _tool_delete(request) {
+        const { promptId, key } = request.params;
+        // Validate required parameters
+        if (!promptId || typeof promptId !== 'string') {
+            throw new Error('promptId is required and must be a string');
+        }
+        if (!key || typeof key !== 'string') {
+            throw new Error('key is required and must be a string');
+        }
+        // Get prompt storage
+        const promptStorage = this.storage.get(promptId);
+        if (!promptStorage) {
+            // Not an error - deleting non-existent key is idempotent
+            return {
+                success: true,
+            };
+        }
+        // Delete key and update metadata
+        promptStorage.delete(key);
+        this.updateLastAccessed(promptId);
+        // Clean up empty prompt namespace
+        if (promptStorage.size === 0) {
+            this.storage.delete(promptId);
+            this.metadata.delete(promptId);
+        }
+        return {
+            success: true,
+        };
+    }
+    /**
+     * Check if a key exists in a prompt namespace
+     * ✅ Throws errors for validation failures
+     * ✅ Returns raw data
+     */
+    async _tool_has(request) {
+        const { promptId, key } = request.params;
+        // Validate required parameters
+        if (!promptId || typeof promptId !== 'string') {
+            throw new Error('promptId is required and must be a string');
+        }
+        if (!key || typeof key !== 'string') {
+            throw new Error('key is required and must be a string');
+        }
+        // Check existence
+        const promptStorage = this.storage.get(promptId);
+        const exists = promptStorage ? promptStorage.has(key) : false;
+        if (exists) {
+            this.updateLastAccessed(promptId);
+        }
+        return {
+            success: exists,
+        };
+    }
+    /**
+     * List all prompt IDs with active storage
+     */
+    async _tool_list_prompts(_request) {
+        const promptIds = Array.from(this.storage.keys());
+        return {
+            promptIds,
+            count: promptIds.length,
+        };
+    }
+    /**
+     * Clear all data for a specific prompt namespace
+     */
+    async _tool_clear_prompt(request) {
+        const { promptId } = request.params;
+        // Validate required parameter
+        if (!promptId || typeof promptId !== 'string') {
+            throw new Error('promptId is required and must be a string');
+        }
+        const promptStorage = this.storage.get(promptId);
+        if (!promptStorage) {
+            return {
+                success: true,
+                keysDeleted: 0,
+            };
+        }
+        const keysDeleted = promptStorage.size;
+        // Clear storage and metadata
+        this.storage.delete(promptId);
+        this.metadata.delete(promptId);
+        return {
+            success: true,
+            keysDeleted,
+        };
+    }
+    /**
+     * Get all keys stored in a specific prompt namespace
+     */
+    async _tool_get_prompt_keys(request) {
+        const { promptId } = request.params;
+        // Validate required parameter
+        if (!promptId || typeof promptId !== 'string') {
+            throw new Error('promptId is required and must be a string');
+        }
+        const promptStorage = this.storage.get(promptId);
+        if (!promptStorage) {
+            return {
+                keys: [],
+                count: 0,
+            };
+        }
+        const keys = Array.from(promptStorage.keys());
+        this.updateLastAccessed(promptId);
+        return {
+            keys,
+            count: keys.length,
+        };
+    }
+    /**
+     * Get statistics for a specific prompt namespace
+     */
+    async _tool_get_prompt_stats(request) {
+        const { promptId } = request.params;
+        // Validate required parameter
+        if (!promptId || typeof promptId !== 'string') {
+            throw new Error('promptId is required and must be a string');
+        }
+        const promptStorage = this.storage.get(promptId);
+        const meta = this.metadata.get(promptId);
+        if (!promptStorage || !meta) {
+            return {
+                promptId,
+                keyCount: 0,
+                lastAccessed: 0,
+                exists: false,
+            };
+        }
+        this.updateLastAccessed(promptId);
+        return {
+            promptId,
+            keyCount: promptStorage.size,
+            lastAccessed: meta.lastAccessed,
+            exists: true,
+            createdAt: meta.createdAt,
+        };
+    }
+    /**
+     * Cleanup resources on stop
+     */
+    async stop() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+        await super.stop();
+    }
+    /**
+     * Update last accessed timestamp for a prompt
+     */
+    updateLastAccessed(promptId) {
+        const meta = this.metadata.get(promptId);
+        if (meta) {
+            meta.lastAccessed = Date.now();
+        }
+    }
+    /**
+     * Clean up prompts that haven't been accessed within TTL
+     */
+    cleanupExpiredPrompts() {
+        if (!this.config.promptTTL)
+            return;
+        const now = Date.now();
+        const expiredPrompts = [];
+        for (const [promptId, meta] of this.metadata.entries()) {
+            if (now - meta.lastAccessed > this.config.promptTTL) {
+                expiredPrompts.push(promptId);
+            }
+        }
+        if (expiredPrompts.length > 0) {
+            for (const promptId of expiredPrompts) {
+                this.storage.delete(promptId);
+                this.metadata.delete(promptId);
+            }
+            this.logger.info('Cleaned up expired prompts', {
+                count: expiredPrompts.length,
+                promptIds: expiredPrompts,
+            });
+        }
+    }
+    /**
+     * Evict the oldest prompt when max limit is reached
+     */
+    evictOldestPrompt() {
+        let oldestPromptId;
+        let oldestTime = Infinity;
+        for (const [promptId, meta] of this.metadata.entries()) {
+            if (meta.lastAccessed < oldestTime) {
+                oldestTime = meta.lastAccessed;
+                oldestPromptId = promptId;
+            }
+        }
+        if (oldestPromptId) {
+            this.storage.delete(oldestPromptId);
+            this.metadata.delete(oldestPromptId);
+            this.logger.info('Evicted oldest prompt', {
+                promptId: oldestPromptId,
+                lastAccessed: oldestTime,
+            });
+        }
+    }
+}

package/dist/test/prompt-seeder.spec.d.ts

@@ -0,0 +1,2 @@
+import 'dotenv/config';
+//# sourceMappingURL=prompt-seeder.spec.d.ts.map

package/dist/test/prompt-seeder.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt-seeder.spec.d.ts","sourceRoot":"","sources":["../../test/prompt-seeder.spec.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,CAAC"}