openclaw-productboard 1.0.0

package/dist/tools/products.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * ProductBoard Product Management Tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProductTools = createProductTools;
+function createProductTools(client) {
+    return [
+        // pb_product_list
+        {
+            name: 'pb_product_list',
+            description: 'List all products in the ProductBoard workspace. Products are top-level containers for organizing features.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of products to return (default: 50)',
+                        default: 50,
+                    },
+                },
+            },
+            handler: async (params) => {
+                const products = await client.listProducts({
+                    limit: params.limit || 50,
+                });
+                return {
+                    count: products.length,
+                    products: products.map((p) => ({
+                        id: p.id,
+                        name: p.name,
+                        description: p.description?.substring(0, 200),
+                        createdAt: p.createdAt,
+                        url: p.links?.html,
+                    })),
+                };
+            },
+        },
+        // pb_product_get
+        {
+            name: 'pb_product_get',
+            description: 'Get detailed information about a specific product by ID, including its components.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: 'Product ID',
+                    },
+                    includeComponents: {
+                        type: 'boolean',
+                        description: 'Include the list of components under this product',
+                        default: true,
+                    },
+                },
+                required: ['id'],
+            },
+            handler: async (params) => {
+                const product = await client.getProduct(params.id);
+                const result = {
+                    id: product.id,
+                    name: product.name,
+                    description: product.description,
+                    createdAt: product.createdAt,
+                    updatedAt: product.updatedAt,
+                    url: product.links?.html,
+                };
+                // Optionally include components
+                if (params.includeComponents !== false) {
+                    const components = await client.listComponents({
+                        productId: product.id,
+                        limit: 100,
+                    });
+                    result.components = components.map((c) => ({
+                        id: c.id,
+                        name: c.name,
+                        description: c.description?.substring(0, 200),
+                    }));
+                    result.componentCount = components.length;
+                }
+                return result;
+            },
+        },
+        // pb_product_hierarchy
+        {
+            name: 'pb_product_hierarchy',
+            description: 'Get the complete product hierarchy including all products and their components. Useful for understanding the workspace structure.',
+            parameters: {
+                type: 'object',
+                properties: {},
+            },
+            handler: async () => {
+                const hierarchy = await client.getProductHierarchy();
+                // Build tree structure
+                const productMap = new Map();
+                // Initialize products
+                for (const product of hierarchy.products) {
+                    productMap.set(product.id, {
+                        id: product.id,
+                        name: product.name,
+                        description: product.description?.substring(0, 200),
+                        components: [],
+                    });
+                }
+                // Build component tree (components can be nested)
+                const componentMap = new Map();
+                for (const component of hierarchy.components) {
+                    componentMap.set(component.id, {
+                        ...component,
+                        subcomponents: [],
+                    });
+                }
+                // Assign components to parents
+                for (const component of hierarchy.components) {
+                    const comp = componentMap.get(component.id);
+                    if (component.parent?.product?.id) {
+                        // Top-level component under a product
+                        const product = productMap.get(component.parent.product.id);
+                        if (product) {
+                            product.components.push({
+                                id: comp.id,
+                                name: comp.name,
+                                description: comp.description?.substring(0, 200),
+                                subcomponents: comp.subcomponents,
+                            });
+                        }
+                    }
+                    else if (component.parent?.component?.id) {
+                        // Nested component
+                        const parent = componentMap.get(component.parent.component.id);
+                        if (parent) {
+                            parent.subcomponents.push({
+                                id: comp.id,
+                                name: comp.name,
+                            });
+                        }
+                    }
+                }
+                return {
+                    productCount: hierarchy.products.length,
+                    componentCount: hierarchy.components.length,
+                    hierarchy: Array.from(productMap.values()),
+                };
+            },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"products.js","sourceRoot":"","sources":["../../src/tools/products.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ProductBoard Product Management Tools\n */\n\nimport { ProductBoardClient } from '../client/api-client';\nimport { ToolDefinition } from '../client/types';\n\nexport function createProductTools(client: ProductBoardClient): ToolDefinition[] {\n  return [\n    // pb_product_list\n    {\n      name: 'pb_product_list',\n      description:\n        'List all products in the ProductBoard workspace. Products are top-level containers for organizing features.',\n      parameters: {\n        type: 'object',\n        properties: {\n          limit: {\n            type: 'number',\n            description: 'Maximum number of products to return (default: 50)',\n            default: 50,\n          },\n        },\n      },\n      handler: async (params) => {\n        const products = await client.listProducts({\n          limit: params.limit as number || 50,\n        });\n        return {\n          count: products.length,\n          products: products.map((p) => ({\n            id: p.id,\n            name: p.name,\n            description: p.description?.substring(0, 200),\n            createdAt: p.createdAt,\n            url: p.links?.html,\n          })),\n        };\n      },\n    },\n\n    // pb_product_get\n    {\n      name: 'pb_product_get',\n      description:\n        'Get detailed information about a specific product by ID, including its components.',\n      parameters: {\n        type: 'object',\n        properties: {\n          id: {\n            type: 'string',\n            description: 'Product ID',\n          },\n          includeComponents: {\n            type: 'boolean',\n            description: 'Include the list of components under this product',\n            default: true,\n          },\n        },\n        required: ['id'],\n      },\n      handler: async (params) => {\n        const product = await client.getProduct(params.id as string);\n\n        const result: Record<string, unknown> = {\n          id: product.id,\n          name: product.name,\n          description: product.description,\n          createdAt: product.createdAt,\n          updatedAt: product.updatedAt,\n          url: product.links?.html,\n        };\n\n        // Optionally include components\n        if (params.includeComponents !== false) {\n          const components = await client.listComponents({\n            productId: product.id,\n            limit: 100,\n          });\n          result.components = components.map((c) => ({\n            id: c.id,\n            name: c.name,\n            description: c.description?.substring(0, 200),\n          }));\n          result.componentCount = components.length;\n        }\n\n        return result;\n      },\n    },\n\n    // pb_product_hierarchy\n    {\n      name: 'pb_product_hierarchy',\n      description:\n        'Get the complete product hierarchy including all products and their components. Useful for understanding the workspace structure.',\n      parameters: {\n        type: 'object',\n        properties: {},\n      },\n      handler: async () => {\n        const hierarchy = await client.getProductHierarchy();\n\n        // Build tree structure\n        const productMap = new Map<string, {\n          id: string;\n          name: string;\n          description?: string;\n          components: Array<{\n            id: string;\n            name: string;\n            description?: string;\n            subcomponents: Array<{ id: string; name: string }>;\n          }>;\n        }>();\n\n        // Initialize products\n        for (const product of hierarchy.products) {\n          productMap.set(product.id, {\n            id: product.id,\n            name: product.name,\n            description: product.description?.substring(0, 200),\n            components: [],\n          });\n        }\n\n        // Build component tree (components can be nested)\n        const componentMap = new Map<string, typeof hierarchy.components[0] & { subcomponents: Array<{ id: string; name: string }> }>();\n\n        for (const component of hierarchy.components) {\n          componentMap.set(component.id, {\n            ...component,\n            subcomponents: [],\n          });\n        }\n\n        // Assign components to parents\n        for (const component of hierarchy.components) {\n          const comp = componentMap.get(component.id)!;\n\n          if (component.parent?.product?.id) {\n            // Top-level component under a product\n            const product = productMap.get(component.parent.product.id);\n            if (product) {\n              product.components.push({\n                id: comp.id,\n                name: comp.name,\n                description: comp.description?.substring(0, 200),\n                subcomponents: comp.subcomponents,\n              });\n            }\n          } else if (component.parent?.component?.id) {\n            // Nested component\n            const parent = componentMap.get(component.parent.component.id);\n            if (parent) {\n              parent.subcomponents.push({\n                id: comp.id,\n                name: comp.name,\n              });\n            }\n          }\n        }\n\n        return {\n          productCount: hierarchy.products.length,\n          componentCount: hierarchy.components.length,\n          hierarchy: Array.from(productMap.values()),\n        };\n      },\n    },\n  ];\n}\n"]}

package/dist/tools/search.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ProductBoard Search and User Tools
+ */
+import { ProductBoardClient } from '../client/api-client';
+import { ToolDefinition } from '../client/types';
+export declare function createSearchTools(client: ProductBoardClient): ToolDefinition[];

package/dist/tools/search.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * ProductBoard Search and User Tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSearchTools = createSearchTools;
+function createSearchTools(client) {
+    return [
+        // pb_search
+        {
+            name: 'pb_search',
+            description: 'Global search across ProductBoard. Searches features, products, components, and notes by name, title, or content.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query text',
+                    },
+                    type: {
+                        type: 'string',
+                        description: 'Limit search to specific type',
+                        enum: ['feature', 'product', 'component', 'note'],
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum results to return (default: 25)',
+                        default: 25,
+                    },
+                },
+                required: ['query'],
+            },
+            handler: async (params) => {
+                const searchParams = {
+                    query: params.query,
+                    type: params.type,
+                    limit: params.limit || 25,
+                };
+                const results = await client.search(searchParams);
+                // Group results by type
+                const grouped = {
+                    features: [],
+                    products: [],
+                    components: [],
+                    notes: [],
+                };
+                for (const result of results) {
+                    const key = result.type + 's';
+                    if (grouped[key]) {
+                        grouped[key].push({
+                            id: result.id,
+                            name: result.name || result.title,
+                            description: result.description || result.content,
+                            url: result.links?.html,
+                        });
+                    }
+                }
+                return {
+                    totalCount: results.length,
+                    query: params.query,
+                    results: grouped,
+                };
+            },
+        },
+        // pb_user_current
+        {
+            name: 'pb_user_current',
+            description: 'Get information about the currently authenticated user, including workspace details.',
+            parameters: {
+                type: 'object',
+                properties: {},
+            },
+            handler: async () => {
+                const user = await client.getCurrentUser();
+                return {
+                    id: user.id,
+                    email: user.email,
+                    name: user.name,
+                    role: user.role,
+                    workspaceId: user.workspaceId,
+                    workspaceName: user.workspaceName,
+                };
+            },
+        },
+        // pb_user_list
+        {
+            name: 'pb_user_list',
+            description: 'List all users in the ProductBoard workspace. Useful for finding user IDs for assigning features.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of users to return (default: 100)',
+                        default: 100,
+                    },
+                },
+            },
+            handler: async (params) => {
+                const users = await client.listUsers({
+                    limit: params.limit || 100,
+                });
+                return {
+                    count: users.length,
+                    users: users.map((u) => ({
+                        id: u.id,
+                        email: u.email,
+                        name: u.name,
+                        role: u.role,
+                    })),
+                };
+            },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.js","sourceRoot":"","sources":["../../src/tools/search.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ProductBoard Search and User Tools\n */\n\nimport { ProductBoardClient } from '../client/api-client';\nimport { ToolDefinition, SearchParams } from '../client/types';\n\nexport function createSearchTools(client: ProductBoardClient): ToolDefinition[] {\n  return [\n    // pb_search\n    {\n      name: 'pb_search',\n      description:\n        'Global search across ProductBoard. Searches features, products, components, and notes by name, title, or content.',\n      parameters: {\n        type: 'object',\n        properties: {\n          query: {\n            type: 'string',\n            description: 'Search query text',\n          },\n          type: {\n            type: 'string',\n            description: 'Limit search to specific type',\n            enum: ['feature', 'product', 'component', 'note'],\n          },\n          limit: {\n            type: 'number',\n            description: 'Maximum results to return (default: 25)',\n            default: 25,\n          },\n        },\n        required: ['query'],\n      },\n      handler: async (params) => {\n        const searchParams: SearchParams = {\n          query: params.query as string,\n          type: params.type as 'feature' | 'note' | 'product' | 'component' | undefined,\n          limit: params.limit as number || 25,\n        };\n\n        const results = await client.search(searchParams);\n\n        // Group results by type\n        const grouped: Record<string, unknown[]> = {\n          features: [],\n          products: [],\n          components: [],\n          notes: [],\n        };\n\n        for (const result of results) {\n          const key = result.type + 's';\n          if (grouped[key]) {\n            grouped[key].push({\n              id: result.id,\n              name: result.name || result.title,\n              description: result.description || result.content,\n              url: result.links?.html,\n            });\n          }\n        }\n\n        return {\n          totalCount: results.length,\n          query: params.query,\n          results: grouped,\n        };\n      },\n    },\n\n    // pb_user_current\n    {\n      name: 'pb_user_current',\n      description:\n        'Get information about the currently authenticated user, including workspace details.',\n      parameters: {\n        type: 'object',\n        properties: {},\n      },\n      handler: async () => {\n        const user = await client.getCurrentUser();\n        return {\n          id: user.id,\n          email: user.email,\n          name: user.name,\n          role: user.role,\n          workspaceId: user.workspaceId,\n          workspaceName: user.workspaceName,\n        };\n      },\n    },\n\n    // pb_user_list\n    {\n      name: 'pb_user_list',\n      description:\n        'List all users in the ProductBoard workspace. Useful for finding user IDs for assigning features.',\n      parameters: {\n        type: 'object',\n        properties: {\n          limit: {\n            type: 'number',\n            description: 'Maximum number of users to return (default: 100)',\n            default: 100,\n          },\n        },\n      },\n      handler: async (params) => {\n        const users = await client.listUsers({\n          limit: params.limit as number || 100,\n        });\n        return {\n          count: users.length,\n          users: users.map((u) => ({\n            id: u.id,\n            email: u.email,\n            name: u.name,\n            role: u.role,\n          })),\n        };\n      },\n    },\n  ];\n}\n"]}

package/dist/utils/cache.d.ts

@@ -0,0 +1,54 @@
+/**
+ * LRU Cache for ProductBoard API responses
+ */
+export interface CacheOptions {
+    /** Time-to-live in milliseconds */
+    ttl: number;
+    /** Maximum number of items to cache */
+    max: number;
+}
+export declare class ApiCache {
+    private cache;
+    constructor(options?: Partial<CacheOptions>);
+    /**
+     * Generate a cache key from tool name and parameters
+     */
+    static generateKey(tool: string, params: Record<string, unknown>): string;
+    /**
+     * Get a value from the cache
+     */
+    get<T>(key: string): T | undefined;
+    /**
+     * Set a value in the cache
+     */
+    set<T>(key: string, value: T, ttl?: number): void;
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key: string): boolean;
+    /**
+     * Delete a value from the cache
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all values from the cache
+     */
+    clear(): void;
+    /**
+     * Invalidate cache entries matching a pattern
+     */
+    invalidatePattern(pattern: string): number;
+    /**
+     * Get cache statistics
+     */
+    stats(): {
+        size: number;
+        max: number;
+    };
+    /**
+     * Wrap an async function with caching
+     */
+    wrap<T>(key: string, fn: () => Promise<T>, ttl?: number): Promise<T>;
+}
+export declare function getCache(options?: Partial<CacheOptions>): ApiCache;
+export declare function resetCache(): void;

package/dist/utils/cache.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * LRU Cache for ProductBoard API responses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiCache = void 0;
+exports.getCache = getCache;
+exports.resetCache = resetCache;
+const lru_cache_1 = require("lru-cache");
+const DEFAULT_OPTIONS = {
+    ttl: 5 * 60 * 1000, // 5 minutes
+    max: 500,
+};
+class ApiCache {
+    cache;
+    constructor(options = {}) {
+        const opts = { ...DEFAULT_OPTIONS, ...options };
+        this.cache = new lru_cache_1.LRUCache({
+            max: opts.max,
+            ttl: opts.ttl,
+        });
+    }
+    /**
+     * Generate a cache key from tool name and parameters
+     */
+    static generateKey(tool, params) {
+        const sortedParams = Object.keys(params)
+            .sort()
+            .reduce((acc, key) => {
+            const value = params[key];
+            if (value !== undefined && value !== null) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        return `${tool}:${JSON.stringify(sortedParams)}`;
+    }
+    /**
+     * Get a value from the cache
+     */
+    get(key) {
+        return this.cache.get(key);
+    }
+    /**
+     * Set a value in the cache
+     */
+    set(key, value, ttl) {
+        if (ttl !== undefined) {
+            this.cache.set(key, value, { ttl });
+        }
+        else {
+            this.cache.set(key, value);
+        }
+    }
+    /**
+     * Check if a key exists in the cache
+     */
+    has(key) {
+        return this.cache.has(key);
+    }
+    /**
+     * Delete a value from the cache
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+    /**
+     * Clear all values from the cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Invalidate cache entries matching a pattern
+     */
+    invalidatePattern(pattern) {
+        let count = 0;
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(pattern)) {
+                this.cache.delete(key);
+                count++;
+            }
+        }
+        return count;
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        return {
+            size: this.cache.size,
+            max: this.cache.max,
+        };
+    }
+    /**
+     * Wrap an async function with caching
+     */
+    async wrap(key, fn, ttl) {
+        const cached = this.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const result = await fn();
+        this.set(key, result, ttl);
+        return result;
+    }
+}
+exports.ApiCache = ApiCache;
+// Singleton instance for the plugin
+let cacheInstance = null;
+function getCache(options) {
+    if (!cacheInstance) {
+        cacheInstance = new ApiCache(options);
+    }
+    return cacheInstance;
+}
+function resetCache() {
+    if (cacheInstance) {
+        cacheInstance.clear();
+    }
+    cacheInstance = null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/rate-limiter.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Token Bucket Rate Limiter for ProductBoard API
+ */
+export interface RateLimiterOptions {
+    /** Maximum tokens in the bucket */
+    maxTokens: number;
+    /** Tokens added per interval */
+    refillRate: number;
+    /** Refill interval in milliseconds */
+    refillInterval: number;
+}
+export declare class RateLimiter {
+    private tokens;
+    private lastRefill;
+    private readonly options;
+    constructor(options?: Partial<RateLimiterOptions>);
+    /**
+     * Refill tokens based on elapsed time
+     */
+    private refill;
+    /**
+     * Try to acquire a token
+     * @returns true if token was acquired, false if rate limited
+     */
+    tryAcquire(): boolean;
+    /**
+     * Acquire a token, waiting if necessary
+     * @returns Promise that resolves when a token is available
+     */
+    acquire(): Promise<void>;
+    /**
+     * Get the time in milliseconds until a token is available
+     */
+    getWaitTime(): number;
+    /**
+     * Get current token count
+     */
+    getTokens(): number;
+    /**
+     * Reset the rate limiter to full capacity
+     */
+    reset(): void;
+    /**
+     * Check if rate limited without consuming a token
+     */
+    isRateLimited(): boolean;
+    /**
+     * Get rate limiter statistics
+     */
+    stats(): {
+        tokens: number;
+        maxTokens: number;
+        waitTime: number;
+    };
+    private sleep;
+}
+export declare function getRateLimiter(options?: Partial<RateLimiterOptions>): RateLimiter;
+export declare function resetRateLimiter(): void;