@poolzin/pool-bot 2026.3.7 → 2026.3.9

package/dist/cli/lazy-commands.js

@@ -0,0 +1,329 @@
+/**
+ * Lazy Command Loading System
+ *
+ * Optimizes CLI startup time by loading commands on-demand
+ * rather than loading all commands at startup.
+ *
+ * This significantly improves startup performance when only
+ * a subset of commands is used.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { Command } from "commander";
+ * import { lazyCommand } from "./lazy-commands.js";
+ *
+ * const program = new Command();
+ *
+ * // Register lazy-loaded command
+ * lazyCommand(program, "agent", "Manage AI agents", async () => {
+ *   const { buildAgentCommand } = await import("./commands/agent.js");
+ *   return buildAgentCommand();
+ * });
+ * ```
+ */
+/**
+ * Global registry for lazy commands
+ */
+class LazyCommandRegistry {
+    commands = new Map();
+    loadTimes = new Map();
+    /**
+     * Register a lazy command
+     */
+    register(options) {
+        if (this.commands.has(options.name)) {
+            throw new Error(`Command "${options.name}" is already registered`);
+        }
+        const entry = {
+            name: options.name,
+            description: options.description,
+            loader: options.loader,
+            aliases: options.aliases ?? [],
+            loaded: false,
+        };
+        this.commands.set(options.name, entry);
+        // Register aliases pointing to main entry
+        for (const alias of options.aliases ?? []) {
+            if (this.commands.has(alias)) {
+                throw new Error(`Alias "${alias}" is already registered`);
+            }
+            this.commands.set(alias, entry);
+        }
+    }
+    /**
+     * Check if a command is registered
+     */
+    has(name) {
+        return this.commands.has(name);
+    }
+    /**
+     * Get a registered command entry
+     */
+    get(name) {
+        return this.commands.get(name);
+    }
+    /**
+     * Get command loading statistics
+     */
+    getStats() {
+        const uniqueCommands = new Set(Array.from(this.commands.values()).map((c) => c.name));
+        const total = uniqueCommands.size;
+        const loadedEntries = Array.from(this.commands.values()).filter((c) => c.loaded && !c.aliases.includes(c.name) // Count main entries only
+        );
+        const loaded = loadedEntries.length;
+        const loadTimes = {};
+        for (const [name, time] of this.loadTimes) {
+            loadTimes[name] = time;
+        }
+        const times = Object.values(loadTimes);
+        const averageLoadTime = times.length > 0 ? times.reduce((a, b) => a + b, 0) / times.length : undefined;
+        return {
+            total,
+            loaded,
+            lazy: total - loaded,
+            averageLoadTime,
+            loadTimes,
+        };
+    }
+    /**
+     * Mark a command as loaded with its load time
+     */
+    markLoaded(name, loadTime) {
+        const entry = this.commands.get(name);
+        if (entry) {
+            entry.loaded = true;
+            entry.loadTime = loadTime;
+            this.loadTimes.set(name, loadTime);
+        }
+    }
+    /**
+     * Mark a command as failed to load
+     */
+    markFailed(name, error) {
+        const entry = this.commands.get(name);
+        if (entry) {
+            entry.error = error;
+        }
+    }
+    /**
+     * Get list of registered command names (main commands only, not aliases)
+     */
+    getCommandNames() {
+        const seen = new Set();
+        const names = [];
+        for (const entry of this.commands.values()) {
+            if (!seen.has(entry.name)) {
+                seen.add(entry.name);
+                names.push(entry.name);
+            }
+        }
+        return names;
+    }
+    /**
+     * Get all entries (for debugging)
+     */
+    getAllEntries() {
+        return Array.from(this.commands.values());
+    }
+    /**
+     * Clear all registrations
+     */
+    clear() {
+        this.commands.clear();
+        this.loadTimes.clear();
+    }
+}
+/**
+ * Global registry instance
+ */
+export const globalLazyCommandRegistry = new LazyCommandRegistry();
+/**
+ * Register a lazy-loaded command with a Commander program
+ *
+ * This creates a placeholder command that will load the actual
+ * implementation only when the command is invoked.
+ *
+ * @param program - The Commander program instance
+ * @param options - Lazy command configuration
+ * @returns The placeholder command (for chaining)
+ *
+ * @example
+ * ```typescript
+ * lazyCommand(program, {
+ *   name: "agent",
+ *   description: "Manage AI agents",
+ *   loader: async () => {
+ *     const { buildAgentCommand } = await import("./commands/agent.js");
+ *     return buildAgentCommand();
+ *   },
+ *   aliases: ["a"]
+ * });
+ * ```
+ */
+export function lazyCommand(program, options) {
+    // Register in global registry
+    globalLazyCommandRegistry.register(options);
+    // Create placeholder command
+    const placeholder = program
+        .command(options.name)
+        .description(options.description);
+    // Add arguments if specified
+    if (options.arguments) {
+        placeholder.arguments(options.arguments);
+    }
+    // Add aliases
+    for (const alias of options.aliases ?? []) {
+        placeholder.alias(alias);
+    }
+    // Set up lazy loading action
+    placeholder.action(async (...actionArgs) => {
+        const startTime = performance.now();
+        try {
+            // Load the actual command module
+            const realCommand = await options.loader();
+            // Calculate load time
+            const loadTime = performance.now() - startTime;
+            globalLazyCommandRegistry.markLoaded(options.name, loadTime);
+            // Execute the loaded command's action with the same arguments
+            // The loaded command should have its own action handler
+            if (realCommand && typeof realCommand.parseAsync === "function") {
+                // If it's a full Command instance, we need to execute its action
+                // Get the action handler from the loaded command
+                const actionHandler = realCommand._actionHandler;
+                if (actionHandler) {
+                    await actionHandler(...actionArgs);
+                }
+                else {
+                    // Fallback: parse with the same arguments
+                    // Remove command object from args and re-parse
+                    const argv = process.argv.slice(2);
+                    await realCommand.parseAsync(argv);
+                }
+            }
+            else {
+                throw new Error(`Loader for "${options.name}" did not return a valid Command instance`);
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            globalLazyCommandRegistry.markFailed(options.name, err);
+            throw new Error(`Failed to load command "${options.name}": ${err.message}`);
+        }
+    });
+    return placeholder;
+}
+/**
+ * Simple shorthand for creating a lazy command with minimal config
+ *
+ * @param program - The Commander program
+ * @param name - Command name
+ * @param description - Command description
+ * @param loader - Async function that loads and returns the command
+ * @returns The placeholder command
+ *
+ * @example
+ * ```typescript
+ * lazy(program, "agent", "Manage agents", async () => {
+ *   const mod = await import("./commands/agent.js");
+ *   return mod.buildAgentCommand();
+ * });
+ * ```
+ */
+export function lazy(program, name, description, loader) {
+    return lazyCommand(program, { name, description, loader });
+}
+/**
+ * Preload commands that are likely to be used
+ *
+ * This can be called after initial setup to preload commands
+ * in the background, improving responsiveness for common commands.
+ *
+ * @param commandNames - Names of commands to preload
+ * @returns Promise that resolves when all preloads are complete
+ */
+export async function preloadCommands(commandNames) {
+    await Promise.all(commandNames.map(async (name) => {
+        const entry = globalLazyCommandRegistry.get(name);
+        if (entry && !entry.loaded) {
+            try {
+                const startTime = performance.now();
+                await entry.loader();
+                globalLazyCommandRegistry.markLoaded(name, performance.now() - startTime);
+            }
+            catch (error) {
+                // Preload errors are non-fatal
+                console.warn(`Failed to preload command "${name}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }));
+}
+/**
+ * Eagerly load all registered commands
+ *
+ * Use this for testing or when startup time doesn't matter.
+ *
+ * @returns Promise that resolves when all commands are loaded
+ */
+export async function loadAllCommands() {
+    const names = globalLazyCommandRegistry.getCommandNames();
+    await preloadCommands(names);
+}
+/**
+ * Get current loading statistics
+ *
+ * @returns Statistics about lazy-loaded commands
+ */
+export function getLazyCommandStats() {
+    return globalLazyCommandRegistry.getStats();
+}
+/**
+ * Performance measurement utilities for command loading
+ */
+export class LoadTimeTracker {
+    measurements = new Map();
+    /**
+     * Measure execution time of a function
+     */
+    async measure(name, fn) {
+        const start = performance.now();
+        try {
+            return await fn();
+        }
+        finally {
+            const duration = performance.now() - start;
+            this.measurements.set(name, duration);
+        }
+    }
+    /**
+     * Get all measurements
+     */
+    getMeasurements() {
+        return Object.fromEntries(this.measurements);
+    }
+    /**
+     * Get total loading time
+     */
+    getTotalTime() {
+        return Array.from(this.measurements.values()).reduce((a, b) => a + b, 0);
+    }
+    /**
+     * Get slowest operations
+     */
+    getSlowest(count = 5) {
+        return Array.from(this.measurements.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, count)
+            .map(([name, time]) => ({ name, time }));
+    }
+    /**
+     * Clear all measurements
+     */
+    clear() {
+        this.measurements.clear();
+    }
+}
+/**
+ * Global load time tracker
+ */
+export const globalLoadTimeTracker = new LoadTimeTracker();

package/dist/cli/program/command-registry.js

@@ -174,6 +174,19 @@ const coreEntries = [
             mod.registerBrowserCli(program);
         },
     },
+    {
+        commands: [
+            {
+                name: "mods",
+                description: "Manage capability modules (SKILL.md discovery, enable, configure)",
+                hasSubcommands: true,
+            },
+        ],
+        register: async ({ program }) => {
+            const mod = await import("./register.skills.js");
+            mod.registerSkillsCli(program);
+        },
+    },
 ];
 function collectCoreCliCommandNames(predicate) {
     const seen = new Set();

package/dist/cli/program/register.skills.js

@@ -0,0 +1,4 @@
+import { registerSkillsCommands } from "../../skills/commands.js";
+export function registerSkillsCli(program) {
+    registerSkillsCommands(program);
+}

package/dist/config/config.js

@@ -2,6 +2,7 @@ export { createConfigIO, loadConfig, parseConfigJson5, readConfigFileSnapshot, r
 export { migrateLegacyConfig } from "./legacy-migrate.js";
 export * from "./paths.js";
 export * from "./runtime-overrides.js";
+export * from "./secrets-integration.js";
 export * from "./types.js";
 export { validateConfigObject, validateConfigObjectWithPlugins } from "./validation.js";
 export { PoolBotSchema } from "./zod-schema.js";

package/dist/config/secrets-integration.js

@@ -0,0 +1,88 @@
+/**
+ * Config Secrets Integration
+ *
+ * Integrates the secrets management system with config loading.
+ * Resolves SecretRefs in config values at runtime.
+ */
+import { SecretsRuntime } from "../secrets/index.js";
+const SECRET_PATHS = [
+    "agent.model",
+    "agent.apiKey",
+    "channels.telegram.botToken",
+    "channels.discord.token",
+    "channels.slack.botToken",
+    "channels.slack.appToken",
+    "gateway.auth.token",
+    "gateway.auth.password",
+    "memory.apiKey",
+    "tools.browser.apiKey",
+];
+/**
+ * Deeply traverse config and resolve secret references
+ */
+export function resolveConfigSecrets(config, secretsRuntime) {
+    const resolved = { ...config };
+    // Resolve specific known secret paths
+    for (const path of SECRET_PATHS) {
+        resolvePath(resolved, path.split("."), secretsRuntime);
+    }
+    // Also scan for any string values that look like secret refs
+    scanAndResolveSecrets(resolved, "", secretsRuntime);
+    return resolved;
+}
+function resolvePath(obj, path, runtime) {
+    if (path.length === 0)
+        return;
+    const [head, ...tail] = path;
+    if (!(head in obj))
+        return;
+    if (tail.length === 0) {
+        // Leaf node - resolve if it's a string
+        const value = obj[head];
+        if (typeof value === "string") {
+            const result = runtime.resolve(head, value);
+            if (result.value !== undefined) {
+                obj[head] = result.value;
+            }
+        }
+    }
+    else {
+        // Traverse deeper
+        const child = obj[head];
+        if (typeof child === "object" && child !== null && !Array.isArray(child)) {
+            resolvePath(child, tail, runtime);
+        }
+    }
+}
+function scanAndResolveSecrets(obj, path, runtime) {
+    if (typeof obj === "string") {
+        // Check if it looks like a secret ref
+        if (obj.startsWith("env:") || obj.startsWith("file:")) {
+            runtime.resolve(path || "unknown", obj);
+        }
+        return;
+    }
+    if (Array.isArray(obj)) {
+        obj.forEach((item, index) => {
+            scanAndResolveSecrets(item, `${path}[${index}]`, runtime);
+        });
+        return;
+    }
+    if (typeof obj === "object" && obj !== null) {
+        for (const [key, value] of Object.entries(obj)) {
+            const newPath = path ? `${path}.${key}` : key;
+            scanAndResolveSecrets(value, newPath, runtime);
+        }
+    }
+}
+/**
+ * Create a secrets runtime from config
+ */
+export function createSecretsRuntimeFromConfig(_config, secretsConfig) {
+    return new SecretsRuntime({
+        allowDirectValues: true,
+        warnOnDirectValues: true,
+        failOnUnresolved: false,
+        ...secretsConfig,
+    });
+}

package/dist/context-engine/index.js

@@ -0,0 +1,33 @@
+/**
+ * Context Engine - Pluggable conversation context management
+ *
+ * @example
+ * ```typescript
+ * import { LegacyContextEngine, globalContextEngineRegistry } from './context-engine/index.js';
+ *
+ * // Register the legacy engine
+ * globalContextEngineRegistry.register('legacy', LegacyContextEngine);
+ *
+ * // Get engine instance
+ * const engine = globalContextEngineRegistry.getEngine('legacy');
+ *
+ * // Bootstrap for a session
+ * await engine.bootstrap({ sessionId: 'session-123' });
+ *
+ * // Ingest a message
+ * await engine.ingest({
+ *   sessionId: 'session-123',
+ *   message: { role: 'user', content: 'Hello!' }
+ * });
+ *
+ * // Assemble context
+ * const result = await engine.assemble({
+ *   sessionId: 'session-123',
+ *   messages: []
+ * });
+ * ```
+ */
+// Registry
+export { ContextEngineRegistry, globalContextEngineRegistry, resolveContextEngine, } from "./registry.js";
+// Legacy Engine
+export { LegacyContextEngine, createLegacyContextEngine, } from "./legacy.js";

package/dist/context-engine/legacy.js

@@ -0,0 +1,181 @@
+/**
+ * Legacy Context Engine
+ *
+ * Maintains PoolBot's original context management behavior.
+ * This is the default engine that preserves backward compatibility.
+ *
+ * Strategy:
+ * - Simple message accumulation
+ * - Truncation-based overflow handling
+ * - Basic compaction via summarization
+ */
+export class LegacyContextEngine {
+    info = {
+        id: "legacy",
+        name: "Legacy Context Engine",
+        description: "PoolBot's original context management with simple accumulation and truncation",
+        supportsVectorSearch: false,
+        supportsFullTextSearch: false,
+        tokenLimit: undefined, // No explicit limit
+    };
+    sessions = new Map();
+    async bootstrap(params) {
+        try {
+            // Initialize session storage
+            this.sessions.set(params.sessionId, {
+                messages: [],
+                lastAccessed: new Date(),
+            });
+            return {
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async ingest(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session) {
+                return {
+                    success: false,
+                    error: `Session ${params.sessionId} not found`,
+                };
+            }
+            session.messages.push(params.message);
+            session.lastAccessed = new Date();
+            // Estimate tokens (rough approximation)
+            const content = typeof params.message.content === "string"
+                ? params.message.content
+                : JSON.stringify(params.message.content);
+            const estimatedTokens = Math.ceil(content.length / 4);
+            return {
+                success: true,
+                tokensConsumed: estimatedTokens,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async assemble(params) {
+        const session = this.sessions.get(params.sessionId);
+        const messages = session?.messages ?? params.messages;
+        // Apply token budget if specified
+        let resultMessages = messages;
+        let wasTruncated = false;
+        let excludedMessages = [];
+        if (params.tokenBudget && params.tokenBudget > 0) {
+            const estimate = this.estimateTokenCount(messages);
+            if (estimate > params.tokenBudget) {
+                // Simple truncation: keep newest messages that fit
+                const reversed = [...messages].reverse();
+                const fitting = [];
+                let currentTokens = 0;
+                for (const msg of reversed) {
+                    const msgTokens = this.estimateTokenCount([msg]);
+                    if (currentTokens + msgTokens <= params.tokenBudget) {
+                        fitting.unshift(msg);
+                        currentTokens += msgTokens;
+                    }
+                    else {
+                        excludedMessages.unshift(msg);
+                    }
+                }
+                resultMessages = fitting;
+                wasTruncated = true;
+            }
+        }
+        return {
+            messages: resultMessages,
+            totalTokens: this.estimateTokenCount(resultMessages),
+            wasTruncated,
+            excludedMessages: wasTruncated ? excludedMessages : undefined,
+        };
+    }
+    async compact(params) {
+        try {
+            const session = this.sessions.get(params.sessionId);
+            if (!session || session.messages.length === 0) {
+                return {
+                    success: true,
+                    tokensSaved: 0,
+                };
+            }
+            const originalTokens = this.estimateTokenCount(session.messages);
+            // Legacy compaction: summarize older messages
+            // Keep recent messages, summarize older ones
+            const keepRecent = 4; // Keep last 2 exchanges
+            const toSummarize = session.messages.slice(0, -keepRecent);
+            const toKeep = session.messages.slice(-keepRecent);
+            if (toSummarize.length === 0) {
+                return {
+                    success: true,
+                    tokensSaved: 0,
+                };
+            }
+            // Create summary message
+            const summary = {
+                role: "system",
+                content: `[${toSummarize.length} earlier messages summarized]`,
+                metadata: { compacted: true, originalCount: toSummarize.length },
+            };
+            session.messages = [summary, ...toKeep];
+            const newTokens = this.estimateTokenCount(session.messages);
+            return {
+                success: true,
+                summary: summary.content,
+                tokensSaved: originalTokens - newTokens,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    async cleanup(params) {
+        this.sessions.delete(params.sessionId);
+    }
+    async getStats(params) {
+        const session = this.sessions.get(params.sessionId);
+        if (!session) {
+            return {
+                messageCount: 0,
+            };
+        }
+        return {
+            messageCount: session.messages.length,
+            totalTokens: this.estimateTokenCount(session.messages),
+            lastAccessed: session.lastAccessed,
+        };
+    }
+    /**
+     * Estimate token count for messages
+     * Rough approximation: ~4 characters per token
+     */
+    estimateTokenCount(messages) {
+        let totalChars = 0;
+        for (const msg of messages) {
+            const content = typeof msg.content === "string"
+                ? msg.content
+                : JSON.stringify(msg.content);
+            totalChars += content.length;
+        }
+        return Math.ceil(totalChars / 4);
+    }
+}
+/**
+ * Create the default legacy context engine
+ */
+export function createLegacyContextEngine() {
+    return new LegacyContextEngine();
+}