openclaw-productboard 1.0.0

package/dist/tools/features.js

@@ -0,0 +1,318 @@
+"use strict";
+/**
+ * ProductBoard Feature Management Tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeatureTools = createFeatureTools;
+function createFeatureTools(client) {
+    return [
+        // pb_feature_create
+        {
+            name: 'pb_feature_create',
+            description: 'Create a new feature in ProductBoard. Features represent product functionality, user stories, or items in your product backlog.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the feature (required)',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Detailed description of the feature (supports HTML)',
+                    },
+                    status: {
+                        type: 'string',
+                        description: 'Feature status',
+                        enum: ['new', 'in-progress', 'shipped', 'archived', 'postponed', 'candidate'],
+                    },
+                    productId: {
+                        type: 'string',
+                        description: 'ID of the parent product to assign this feature to',
+                    },
+                    componentId: {
+                        type: 'string',
+                        description: 'ID of the parent component to assign this feature to',
+                    },
+                    parentFeatureId: {
+                        type: 'string',
+                        description: 'ID of the parent feature (for sub-features)',
+                    },
+                    ownerEmail: {
+                        type: 'string',
+                        description: 'Email of the feature owner',
+                    },
+                    startDate: {
+                        type: 'string',
+                        description: 'Planned start date (ISO 8601 format)',
+                    },
+                    endDate: {
+                        type: 'string',
+                        description: 'Planned end date (ISO 8601 format)',
+                    },
+                },
+                required: ['name'],
+            },
+            handler: async (params) => {
+                const createParams = {
+                    name: params.name,
+                    description: params.description,
+                    status: params.status,
+                };
+                // Build parent reference
+                if (params.productId || params.componentId || params.parentFeatureId) {
+                    createParams.parent = {};
+                    if (params.productId)
+                        createParams.parent.product = { id: params.productId };
+                    if (params.componentId)
+                        createParams.parent.component = { id: params.componentId };
+                    if (params.parentFeatureId)
+                        createParams.parent.feature = { id: params.parentFeatureId };
+                }
+                // Set owner
+                if (params.ownerEmail) {
+                    createParams.owner = { email: params.ownerEmail };
+                }
+                // Set timeframe
+                if (params.startDate || params.endDate) {
+                    createParams.timeframe = {
+                        startDate: params.startDate,
+                        endDate: params.endDate,
+                    };
+                }
+                const feature = await client.createFeature(createParams);
+                return {
+                    success: true,
+                    feature: {
+                        id: feature.id,
+                        name: feature.name,
+                        status: feature.status,
+                        url: feature.links?.html,
+                    },
+                };
+            },
+        },
+        // pb_feature_list
+        {
+            name: 'pb_feature_list',
+            description: 'List features in ProductBoard with optional filters. Returns features from your product backlog.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    productId: {
+                        type: 'string',
+                        description: 'Filter by product ID',
+                    },
+                    componentId: {
+                        type: 'string',
+                        description: 'Filter by component ID',
+                    },
+                    status: {
+                        type: 'string',
+                        description: 'Filter by status',
+                        enum: ['new', 'in-progress', 'shipped', 'archived', 'postponed', 'candidate'],
+                    },
+                    ownerId: {
+                        type: 'string',
+                        description: 'Filter by owner ID',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of features to return (default: 50, max: 500)',
+                        default: 50,
+                    },
+                },
+            },
+            handler: async (params) => {
+                const listParams = {
+                    productId: params.productId,
+                    componentId: params.componentId,
+                    status: params.status,
+                    ownerId: params.ownerId,
+                    limit: Math.min(params.limit || 50, 500),
+                };
+                const features = await client.listFeatures(listParams);
+                return {
+                    count: features.length,
+                    features: features.map((f) => ({
+                        id: f.id,
+                        name: f.name,
+                        status: f.status,
+                        description: f.description?.substring(0, 200),
+                        owner: f.owner?.email,
+                        url: f.links?.html,
+                    })),
+                };
+            },
+        },
+        // pb_feature_get
+        {
+            name: 'pb_feature_get',
+            description: 'Get detailed information about a specific feature by ID.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: 'Feature ID',
+                    },
+                },
+                required: ['id'],
+            },
+            handler: async (params) => {
+                const feature = await client.getFeature(params.id);
+                return {
+                    id: feature.id,
+                    name: feature.name,
+                    description: feature.description,
+                    status: feature.status,
+                    owner: feature.owner?.email,
+                    parent: feature.parent,
+                    timeframe: feature.timeframe,
+                    createdAt: feature.createdAt,
+                    updatedAt: feature.updatedAt,
+                    url: feature.links?.html,
+                };
+            },
+        },
+        // pb_feature_update
+        {
+            name: 'pb_feature_update',
+            description: 'Update an existing feature in ProductBoard. Only provided fields will be updated.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: 'Feature ID to update',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'New name for the feature',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'New description (supports HTML)',
+                    },
+                    status: {
+                        type: 'string',
+                        description: 'New status',
+                        enum: ['new', 'in-progress', 'shipped', 'archived', 'postponed', 'candidate'],
+                    },
+                    productId: {
+                        type: 'string',
+                        description: 'Move to a different product',
+                    },
+                    componentId: {
+                        type: 'string',
+                        description: 'Move to a different component',
+                    },
+                    ownerEmail: {
+                        type: 'string',
+                        description: 'New owner email',
+                    },
+                    startDate: {
+                        type: 'string',
+                        description: 'New start date (ISO 8601)',
+                    },
+                    endDate: {
+                        type: 'string',
+                        description: 'New end date (ISO 8601)',
+                    },
+                },
+                required: ['id'],
+            },
+            handler: async (params) => {
+                const updateParams = {};
+                if (params.name)
+                    updateParams.name = params.name;
+                if (params.description)
+                    updateParams.description = params.description;
+                if (params.status)
+                    updateParams.status = params.status;
+                if (params.productId || params.componentId) {
+                    updateParams.parent = {};
+                    if (params.productId)
+                        updateParams.parent.product = { id: params.productId };
+                    if (params.componentId)
+                        updateParams.parent.component = { id: params.componentId };
+                }
+                if (params.ownerEmail) {
+                    updateParams.owner = { email: params.ownerEmail };
+                }
+                if (params.startDate || params.endDate) {
+                    updateParams.timeframe = {
+                        startDate: params.startDate,
+                        endDate: params.endDate,
+                    };
+                }
+                const feature = await client.updateFeature(params.id, updateParams);
+                return {
+                    success: true,
+                    feature: {
+                        id: feature.id,
+                        name: feature.name,
+                        status: feature.status,
+                        url: feature.links?.html,
+                    },
+                };
+            },
+        },
+        // pb_feature_delete
+        {
+            name: 'pb_feature_delete',
+            description: 'Archive/delete a feature from ProductBoard. This action can be undone in ProductBoard.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: 'Feature ID to delete',
+                    },
+                },
+                required: ['id'],
+            },
+            handler: async (params) => {
+                await client.deleteFeature(params.id);
+                return {
+                    success: true,
+                    message: `Feature ${params.id} has been archived`,
+                };
+            },
+        },
+        // pb_feature_search
+        {
+            name: 'pb_feature_search',
+            description: 'Search for features by name or description. Returns matching features ordered by relevance.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: {
+                        type: 'string',
+                        description: 'Search query (searches name and description)',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum results to return (default: 20)',
+                        default: 20,
+                    },
+                },
+                required: ['query'],
+            },
+            handler: async (params) => {
+                const features = await client.searchFeatures(params.query, params.limit || 20);
+                return {
+                    count: features.length,
+                    features: features.map((f) => ({
+                        id: f.id,
+                        name: f.name,
+                        status: f.status,
+                        description: f.description?.substring(0, 200),
+                        url: f.links?.html,
+                    })),
+                };
+            },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"features.js","sourceRoot":"","sources":["../../src/tools/features.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ProductBoard Feature Management Tools\n */\n\nimport { ProductBoardClient } from '../client/api-client';\nimport {\n  ToolDefinition,\n  CreateFeatureParams,\n  UpdateFeatureParams,\n  ListFeaturesParams,\n  FeatureStatus,\n} from '../client/types';\n\nexport function createFeatureTools(client: ProductBoardClient): ToolDefinition[] {\n  return [\n    // pb_feature_create\n    {\n      name: 'pb_feature_create',\n      description:\n        'Create a new feature in ProductBoard. Features represent product functionality, user stories, or items in your product backlog.',\n      parameters: {\n        type: 'object',\n        properties: {\n          name: {\n            type: 'string',\n            description: 'Name of the feature (required)',\n          },\n          description: {\n            type: 'string',\n            description: 'Detailed description of the feature (supports HTML)',\n          },\n          status: {\n            type: 'string',\n            description: 'Feature status',\n            enum: ['new', 'in-progress', 'shipped', 'archived', 'postponed', 'candidate'],\n          },\n          productId: {\n            type: 'string',\n            description: 'ID of the parent product to assign this feature to',\n          },\n          componentId: {\n            type: 'string',\n            description: 'ID of the parent component to assign this feature to',\n          },\n          parentFeatureId: {\n            type: 'string',\n            description: 'ID of the parent feature (for sub-features)',\n          },\n          ownerEmail: {\n            type: 'string',\n            description: 'Email of the feature owner',\n          },\n          startDate: {\n            type: 'string',\n            description: 'Planned start date (ISO 8601 format)',\n          },\n          endDate: {\n            type: 'string',\n            description: 'Planned end date (ISO 8601 format)',\n          },\n        },\n        required: ['name'],\n      },\n      handler: async (params) => {\n        const createParams: CreateFeatureParams = {\n          name: params.name as string,\n          description: params.description as string | undefined,\n          status: params.status as FeatureStatus | undefined,\n        };\n\n        // Build parent reference\n        if (params.productId || params.componentId || params.parentFeatureId) {\n          createParams.parent = {};\n          if (params.productId) createParams.parent.product = { id: params.productId as string };\n          if (params.componentId) createParams.parent.component = { id: params.componentId as string };\n          if (params.parentFeatureId) createParams.parent.feature = { id: params.parentFeatureId as string };\n        }\n\n        // Set owner\n        if (params.ownerEmail) {\n          createParams.owner = { email: params.ownerEmail as string };\n        }\n\n        // Set timeframe\n        if (params.startDate || params.endDate) {\n          createParams.timeframe = {\n            startDate: params.startDate as string | undefined,\n            endDate: params.endDate as string | undefined,\n          };\n        }\n\n        const feature = await client.createFeature(createParams);\n        return {\n          success: true,\n          feature: {\n            id: feature.id,\n            name: feature.name,\n            status: feature.status,\n            url: feature.links?.html,\n          },\n        };\n      },\n    },\n\n    // pb_feature_list\n    {\n      name: 'pb_feature_list',\n      description:\n        'List features in ProductBoard with optional filters. Returns features from your product backlog.',\n      parameters: {\n        type: 'object',\n        properties: {\n          productId: {\n            type: 'string',\n            description: 'Filter by product ID',\n          },\n          componentId: {\n            type: 'string',\n            description: 'Filter by component ID',\n          },\n          status: {\n            type: 'string',\n            description: 'Filter by status',\n            enum: ['new', 'in-progress', 'shipped', 'archived', 'postponed', 'candidate'],\n          },\n          ownerId: {\n            type: 'string',\n            description: 'Filter by owner ID',\n          },\n          limit: {\n            type: 'number',\n            description: 'Maximum number of features to return (default: 50, max: 500)',\n            default: 50,\n          },\n        },\n      },\n      handler: async (params) => {\n        const listParams: ListFeaturesParams = {\n          productId: params.productId as string | undefined,\n          componentId: params.componentId as string | undefined,\n          status: params.status as FeatureStatus | undefined,\n          ownerId: params.ownerId as string | undefined,\n          limit: Math.min(params.limit as number || 50, 500),\n        };\n\n        const features = await client.listFeatures(listParams);\n        return {\n          count: features.length,\n          features: features.map((f) => ({\n            id: f.id,\n            name: f.name,\n            status: f.status,\n            description: f.description?.substring(0, 200),\n            owner: f.owner?.email,\n            url: f.links?.html,\n          })),\n        };\n      },\n    },\n\n    // pb_feature_get\n    {\n      name: 'pb_feature_get',\n      description:\n        'Get detailed information about a specific feature by ID.',\n      parameters: {\n        type: 'object',\n        properties: {\n          id: {\n            type: 'string',\n            description: 'Feature ID',\n          },\n        },\n        required: ['id'],\n      },\n      handler: async (params) => {\n        const feature = await client.getFeature(params.id as string);\n        return {\n          id: feature.id,\n          name: feature.name,\n          description: feature.description,\n          status: feature.status,\n          owner: feature.owner?.email,\n          parent: feature.parent,\n          timeframe: feature.timeframe,\n          createdAt: feature.createdAt,\n          updatedAt: feature.updatedAt,\n          url: feature.links?.html,\n        };\n      },\n    },\n\n    // pb_feature_update\n    {\n      name: 'pb_feature_update',\n      description:\n        'Update an existing feature in ProductBoard. Only provided fields will be updated.',\n      parameters: {\n        type: 'object',\n        properties: {\n          id: {\n            type: 'string',\n            description: 'Feature ID to update',\n          },\n          name: {\n            type: 'string',\n            description: 'New name for the feature',\n          },\n          description: {\n            type: 'string',\n            description: 'New description (supports HTML)',\n          },\n          status: {\n            type: 'string',\n            description: 'New status',\n            enum: ['new', 'in-progress', 'shipped', 'archived', 'postponed', 'candidate'],\n          },\n          productId: {\n            type: 'string',\n            description: 'Move to a different product',\n          },\n          componentId: {\n            type: 'string',\n            description: 'Move to a different component',\n          },\n          ownerEmail: {\n            type: 'string',\n            description: 'New owner email',\n          },\n          startDate: {\n            type: 'string',\n            description: 'New start date (ISO 8601)',\n          },\n          endDate: {\n            type: 'string',\n            description: 'New end date (ISO 8601)',\n          },\n        },\n        required: ['id'],\n      },\n      handler: async (params) => {\n        const updateParams: UpdateFeatureParams = {};\n\n        if (params.name) updateParams.name = params.name as string;\n        if (params.description) updateParams.description = params.description as string;\n        if (params.status) updateParams.status = params.status as FeatureStatus;\n\n        if (params.productId || params.componentId) {\n          updateParams.parent = {};\n          if (params.productId) updateParams.parent.product = { id: params.productId as string };\n          if (params.componentId) updateParams.parent.component = { id: params.componentId as string };\n        }\n\n        if (params.ownerEmail) {\n          updateParams.owner = { email: params.ownerEmail as string };\n        }\n\n        if (params.startDate || params.endDate) {\n          updateParams.timeframe = {\n            startDate: params.startDate as string | undefined,\n            endDate: params.endDate as string | undefined,\n          };\n        }\n\n        const feature = await client.updateFeature(params.id as string, updateParams);\n        return {\n          success: true,\n          feature: {\n            id: feature.id,\n            name: feature.name,\n            status: feature.status,\n            url: feature.links?.html,\n          },\n        };\n      },\n    },\n\n    // pb_feature_delete\n    {\n      name: 'pb_feature_delete',\n      description:\n        'Archive/delete a feature from ProductBoard. This action can be undone in ProductBoard.',\n      parameters: {\n        type: 'object',\n        properties: {\n          id: {\n            type: 'string',\n            description: 'Feature ID to delete',\n          },\n        },\n        required: ['id'],\n      },\n      handler: async (params) => {\n        await client.deleteFeature(params.id as string);\n        return {\n          success: true,\n          message: `Feature ${params.id} has been archived`,\n        };\n      },\n    },\n\n    // pb_feature_search\n    {\n      name: 'pb_feature_search',\n      description:\n        'Search for features by name or description. Returns matching features ordered by relevance.',\n      parameters: {\n        type: 'object',\n        properties: {\n          query: {\n            type: 'string',\n            description: 'Search query (searches name and description)',\n          },\n          limit: {\n            type: 'number',\n            description: 'Maximum results to return (default: 20)',\n            default: 20,\n          },\n        },\n        required: ['query'],\n      },\n      handler: async (params) => {\n        const features = await client.searchFeatures(\n          params.query as string,\n          params.limit as number || 20\n        );\n        return {\n          count: features.length,\n          features: features.map((f) => ({\n            id: f.id,\n            name: f.name,\n            status: f.status,\n            description: f.description?.substring(0, 200),\n            url: f.links?.html,\n          })),\n        };\n      },\n    },\n  ];\n}\n"]}

package/dist/tools/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * ProductBoard Tools - Export all tool creators
+ */
+export { createFeatureTools } from './features';
+export { createProductTools } from './products';
+export { createNoteTools } from './notes';
+export { createSearchTools } from './search';

package/dist/tools/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * ProductBoard Tools - Export all tool creators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSearchTools = exports.createNoteTools = exports.createProductTools = exports.createFeatureTools = void 0;
+var features_1 = require("./features");
+Object.defineProperty(exports, "createFeatureTools", { enumerable: true, get: function () { return features_1.createFeatureTools; } });
+var products_1 = require("./products");
+Object.defineProperty(exports, "createProductTools", { enumerable: true, get: function () { return products_1.createProductTools; } });
+var notes_1 = require("./notes");
+Object.defineProperty(exports, "createNoteTools", { enumerable: true, get: function () { return notes_1.createNoteTools; } });
+var search_1 = require("./search");
+Object.defineProperty(exports, "createSearchTools", { enumerable: true, get: function () { return search_1.createSearchTools; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHOzs7QUFFSCx1Q0FBZ0Q7QUFBdkMsOEdBQUEsa0JBQWtCLE9BQUE7QUFDM0IsdUNBQWdEO0FBQXZDLDhHQUFBLGtCQUFrQixPQUFBO0FBQzNCLGlDQUEwQztBQUFqQyx3R0FBQSxlQUFlLE9BQUE7QUFDeEIsbUNBQTZDO0FBQXBDLDJHQUFBLGlCQUFpQixPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQcm9kdWN0Qm9hcmQgVG9vbHMgLSBFeHBvcnQgYWxsIHRvb2wgY3JlYXRvcnNcbiAqL1xuXG5leHBvcnQgeyBjcmVhdGVGZWF0dXJlVG9vbHMgfSBmcm9tICcuL2ZlYXR1cmVzJztcbmV4cG9ydCB7IGNyZWF0ZVByb2R1Y3RUb29scyB9IGZyb20gJy4vcHJvZHVjdHMnO1xuZXhwb3J0IHsgY3JlYXRlTm90ZVRvb2xzIH0gZnJvbSAnLi9ub3Rlcyc7XG5leHBvcnQgeyBjcmVhdGVTZWFyY2hUb29scyB9IGZyb20gJy4vc2VhcmNoJztcbiJdfQ==

package/dist/tools/notes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ProductBoard Note/Feedback Management Tools
+ */
+import { ProductBoardClient } from '../client/api-client';
+import { ToolDefinition } from '../client/types';
+export declare function createNoteTools(client: ProductBoardClient): ToolDefinition[];

package/dist/tools/notes.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * ProductBoard Note/Feedback Management Tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNoteTools = createNoteTools;
+function createNoteTools(client) {
+    return [
+        // pb_note_create
+        {
+            name: 'pb_note_create',
+            description: 'Create a customer feedback note in ProductBoard. Notes capture customer insights, feature requests, or user feedback that can be linked to features.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    content: {
+                        type: 'string',
+                        description: 'The note content/feedback text (required, supports HTML)',
+                    },
+                    title: {
+                        type: 'string',
+                        description: 'Optional title for the note',
+                    },
+                    displayUrl: {
+                        type: 'string',
+                        description: 'URL to the original source (e.g., support ticket, Slack message)',
+                    },
+                    sourceOrigin: {
+                        type: 'string',
+                        description: 'Origin system identifier (e.g., "zendesk", "intercom", "slack")',
+                    },
+                    sourceRecordId: {
+                        type: 'string',
+                        description: 'Record ID in the origin system',
+                    },
+                    userEmail: {
+                        type: 'string',
+                        description: 'Email of the user who provided the feedback',
+                    },
+                    userName: {
+                        type: 'string',
+                        description: 'Name of the user who provided the feedback',
+                    },
+                    companyName: {
+                        type: 'string',
+                        description: 'Company/organization name of the feedback source',
+                    },
+                    companyId: {
+                        type: 'string',
+                        description: 'External company ID',
+                    },
+                    tags: {
+                        type: 'array',
+                        description: 'Array of tags to categorize the note',
+                        items: { type: 'string' },
+                    },
+                },
+                required: ['content'],
+            },
+            handler: async (params) => {
+                const createParams = {
+                    content: params.content,
+                    title: params.title,
+                    displayUrl: params.displayUrl,
+                    tags: params.tags,
+                };
+                // Set source if provided
+                if (params.sourceOrigin || params.sourceRecordId) {
+                    createParams.source = {
+                        origin: params.sourceOrigin,
+                        record_id: params.sourceRecordId,
+                    };
+                }
+                // Set user if provided
+                if (params.userEmail) {
+                    createParams.user = {
+                        email: params.userEmail,
+                        name: params.userName,
+                    };
+                }
+                // Set company if provided
+                if (params.companyName || params.companyId) {
+                    createParams.company = {
+                        name: params.companyName,
+                        id: params.companyId,
+                    };
+                }
+                const note = await client.createNote(createParams);
+                return {
+                    success: true,
+                    note: {
+                        id: note.id,
+                        title: note.title,
+                        content: note.content?.substring(0, 200),
+                        user: note.user?.email,
+                        company: note.company?.name,
+                        tags: note.tags,
+                        url: note.links?.html,
+                    },
+                };
+            },
+        },
+        // pb_note_list
+        {
+            name: 'pb_note_list',
+            description: 'List customer feedback notes in ProductBoard. Can filter by date range.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    limit: {
+                        type: 'number',
+                        description: 'Maximum number of notes to return (default: 50)',
+                        default: 50,
+                    },
+                    createdFrom: {
+                        type: 'string',
+                        description: 'Filter notes created on or after this date (ISO 8601)',
+                    },
+                    createdTo: {
+                        type: 'string',
+                        description: 'Filter notes created on or before this date (ISO 8601)',
+                    },
+                },
+            },
+            handler: async (params) => {
+                const listParams = {
+                    limit: params.limit || 50,
+                    createdFrom: params.createdFrom,
+                    createdTo: params.createdTo,
+                };
+                const notes = await client.listNotes(listParams);
+                return {
+                    count: notes.length,
+                    notes: notes.map((n) => ({
+                        id: n.id,
+                        title: n.title,
+                        content: n.content?.substring(0, 200),
+                        user: n.user?.email,
+                        company: n.company?.name,
+                        tags: n.tags,
+                        featureCount: n.features?.length || 0,
+                        createdAt: n.createdAt,
+                        url: n.links?.html,
+                    })),
+                };
+            },
+        },
+        // pb_note_attach
+        {
+            name: 'pb_note_attach',
+            description: 'Attach a note to a feature. This links customer feedback to a specific feature for insights aggregation.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    noteId: {
+                        type: 'string',
+                        description: 'ID of the note to attach',
+                    },
+                    featureId: {
+                        type: 'string',
+                        description: 'ID of the feature to attach the note to',
+                    },
+                },
+                required: ['noteId', 'featureId'],
+            },
+            handler: async (params) => {
+                await client.attachNoteToFeature(params.noteId, params.featureId);
+                return {
+                    success: true,
+                    message: `Note ${params.noteId} has been attached to feature ${params.featureId}`,
+                };
+            },
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notes.js","sourceRoot":"","sources":["../../src/tools/notes.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ProductBoard Note/Feedback Management Tools\n */\n\nimport { ProductBoardClient } from '../client/api-client';\nimport { ToolDefinition, CreateNoteParams, ListNotesParams } from '../client/types';\n\nexport function createNoteTools(client: ProductBoardClient): ToolDefinition[] {\n  return [\n    // pb_note_create\n    {\n      name: 'pb_note_create',\n      description:\n        'Create a customer feedback note in ProductBoard. Notes capture customer insights, feature requests, or user feedback that can be linked to features.',\n      parameters: {\n        type: 'object',\n        properties: {\n          content: {\n            type: 'string',\n            description: 'The note content/feedback text (required, supports HTML)',\n          },\n          title: {\n            type: 'string',\n            description: 'Optional title for the note',\n          },\n          displayUrl: {\n            type: 'string',\n            description: 'URL to the original source (e.g., support ticket, Slack message)',\n          },\n          sourceOrigin: {\n            type: 'string',\n            description: 'Origin system identifier (e.g., \"zendesk\", \"intercom\", \"slack\")',\n          },\n          sourceRecordId: {\n            type: 'string',\n            description: 'Record ID in the origin system',\n          },\n          userEmail: {\n            type: 'string',\n            description: 'Email of the user who provided the feedback',\n          },\n          userName: {\n            type: 'string',\n            description: 'Name of the user who provided the feedback',\n          },\n          companyName: {\n            type: 'string',\n            description: 'Company/organization name of the feedback source',\n          },\n          companyId: {\n            type: 'string',\n            description: 'External company ID',\n          },\n          tags: {\n            type: 'array',\n            description: 'Array of tags to categorize the note',\n            items: { type: 'string' },\n          },\n        },\n        required: ['content'],\n      },\n      handler: async (params) => {\n        const createParams: CreateNoteParams = {\n          content: params.content as string,\n          title: params.title as string | undefined,\n          displayUrl: params.displayUrl as string | undefined,\n          tags: params.tags as string[] | undefined,\n        };\n\n        // Set source if provided\n        if (params.sourceOrigin || params.sourceRecordId) {\n          createParams.source = {\n            origin: params.sourceOrigin as string | undefined,\n            record_id: params.sourceRecordId as string | undefined,\n          };\n        }\n\n        // Set user if provided\n        if (params.userEmail) {\n          createParams.user = {\n            email: params.userEmail as string,\n            name: params.userName as string | undefined,\n          };\n        }\n\n        // Set company if provided\n        if (params.companyName || params.companyId) {\n          createParams.company = {\n            name: params.companyName as string | undefined,\n            id: params.companyId as string | undefined,\n          };\n        }\n\n        const note = await client.createNote(createParams);\n        return {\n          success: true,\n          note: {\n            id: note.id,\n            title: note.title,\n            content: note.content?.substring(0, 200),\n            user: note.user?.email,\n            company: note.company?.name,\n            tags: note.tags,\n            url: note.links?.html,\n          },\n        };\n      },\n    },\n\n    // pb_note_list\n    {\n      name: 'pb_note_list',\n      description:\n        'List customer feedback notes in ProductBoard. Can filter by date range.',\n      parameters: {\n        type: 'object',\n        properties: {\n          limit: {\n            type: 'number',\n            description: 'Maximum number of notes to return (default: 50)',\n            default: 50,\n          },\n          createdFrom: {\n            type: 'string',\n            description: 'Filter notes created on or after this date (ISO 8601)',\n          },\n          createdTo: {\n            type: 'string',\n            description: 'Filter notes created on or before this date (ISO 8601)',\n          },\n        },\n      },\n      handler: async (params) => {\n        const listParams: ListNotesParams = {\n          limit: params.limit as number || 50,\n          createdFrom: params.createdFrom as string | undefined,\n          createdTo: params.createdTo as string | undefined,\n        };\n\n        const notes = await client.listNotes(listParams);\n        return {\n          count: notes.length,\n          notes: notes.map((n) => ({\n            id: n.id,\n            title: n.title,\n            content: n.content?.substring(0, 200),\n            user: n.user?.email,\n            company: n.company?.name,\n            tags: n.tags,\n            featureCount: n.features?.length || 0,\n            createdAt: n.createdAt,\n            url: n.links?.html,\n          })),\n        };\n      },\n    },\n\n    // pb_note_attach\n    {\n      name: 'pb_note_attach',\n      description:\n        'Attach a note to a feature. This links customer feedback to a specific feature for insights aggregation.',\n      parameters: {\n        type: 'object',\n        properties: {\n          noteId: {\n            type: 'string',\n            description: 'ID of the note to attach',\n          },\n          featureId: {\n            type: 'string',\n            description: 'ID of the feature to attach the note to',\n          },\n        },\n        required: ['noteId', 'featureId'],\n      },\n      handler: async (params) => {\n        await client.attachNoteToFeature(\n          params.noteId as string,\n          params.featureId as string\n        );\n        return {\n          success: true,\n          message: `Note ${params.noteId} has been attached to feature ${params.featureId}`,\n        };\n      },\n    },\n  ];\n}\n"]}

package/dist/tools/products.d.ts

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