@lovelybunch/mcp 1.0.75-alpha.8 → 1.0.75

package/src/resources-tool.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for resources tool definition
+ */
+
+import { describe, it, expect } from 'vitest';
+import { resourcesTool } from './resources-tool.js';
+
+describe('resourcesTool', () => {
+  it('should have correct name', () => {
+    expect(resourcesTool.name).toBe('resources');
+  });
+
+  it('should have a description', () => {
+    expect(resourcesTool.description).toBeTruthy();
+    expect(resourcesTool.description).toContain('resource');
+  });
+
+  it('should have correct parameter structure', () => {
+    expect(resourcesTool.parameters.type).toBe('object');
+    expect(resourcesTool.parameters.required).toContain('operation');
+    expect(resourcesTool.parameters.additionalProperties).toBe(false);
+  });
+
+  describe('operations', () => {
+    it('should include all six operations', () => {
+      const ops = resourcesTool.parameters.properties.operation.enum;
+      expect(ops).toContain('list');
+      expect(ops).toContain('get');
+      expect(ops).toContain('generate_image');
+      expect(ops).toContain('generate_audio');
+      expect(ops).toContain('generate_video');
+      expect(ops).toContain('add_from_url');
+      expect(ops).toHaveLength(6);
+    });
+  });
+
+  describe('READ parameters', () => {
+    it('should have query parameter for list filtering', () => {
+      expect(resourcesTool.parameters.properties.query).toBeDefined();
+      expect(resourcesTool.parameters.properties.query.type).toBe('string');
+    });
+
+    it('should have type_filter parameter', () => {
+      expect(resourcesTool.parameters.properties.type_filter).toBeDefined();
+      expect(resourcesTool.parameters.properties.type_filter.type).toBe('string');
+    });
+
+    it('should have resource_id parameter for get', () => {
+      expect(resourcesTool.parameters.properties.resource_id).toBeDefined();
+      expect(resourcesTool.parameters.properties.resource_id.type).toBe('string');
+    });
+  });
+
+  describe('generate_image parameters', () => {
+    it('should have prompt parameter', () => {
+      expect(resourcesTool.parameters.properties.prompt).toBeDefined();
+      expect(resourcesTool.parameters.properties.prompt.type).toBe('string');
+    });
+
+    it('should have model parameter with valid enum values', () => {
+      const modelParam = resourcesTool.parameters.properties.model;
+      expect(modelParam).toBeDefined();
+      expect(modelParam.type).toBe('string');
+      expect(modelParam.enum).toContain('nano-banana-pro');
+      expect(modelParam.enum).toContain('flux-2-dev');
+      expect(modelParam.enum).toContain('flux-2-pro');
+      expect(modelParam.enum).toContain('gpt-image-1.5');
+    });
+
+    it('should have aspect_ratio parameter', () => {
+      expect(resourcesTool.parameters.properties.aspect_ratio).toBeDefined();
+      expect(resourcesTool.parameters.properties.aspect_ratio.type).toBe('string');
+    });
+  });
+
+  describe('generate_audio parameters', () => {
+    it('should have text parameter', () => {
+      expect(resourcesTool.parameters.properties.text).toBeDefined();
+      expect(resourcesTool.parameters.properties.text.type).toBe('string');
+    });
+
+    it('should have voice parameter', () => {
+      expect(resourcesTool.parameters.properties.voice).toBeDefined();
+      expect(resourcesTool.parameters.properties.voice.type).toBe('string');
+    });
+  });
+
+  describe('generate_video parameters', () => {
+    it('should have duration parameter', () => {
+      expect(resourcesTool.parameters.properties.duration).toBeDefined();
+      expect(resourcesTool.parameters.properties.duration.type).toBe('number');
+    });
+
+    it('should have resolution parameter', () => {
+      expect(resourcesTool.parameters.properties.resolution).toBeDefined();
+      expect(resourcesTool.parameters.properties.resolution.type).toBe('string');
+    });
+  });
+
+  describe('add_from_url parameters', () => {
+    it('should have url parameter', () => {
+      expect(resourcesTool.parameters.properties.url).toBeDefined();
+      expect(resourcesTool.parameters.properties.url.type).toBe('string');
+    });
+  });
+
+  describe('shared metadata parameters', () => {
+    it('should have tags parameter', () => {
+      expect(resourcesTool.parameters.properties.tags).toBeDefined();
+      expect(resourcesTool.parameters.properties.tags.type).toBe('string');
+    });
+
+    it('should have description parameter', () => {
+      expect(resourcesTool.parameters.properties.description).toBeDefined();
+      expect(resourcesTool.parameters.properties.description.type).toBe('string');
+    });
+  });
+
+  describe('schema validation compatibility', () => {
+    it('should only require operation (all other params are optional)', () => {
+      expect(resourcesTool.parameters.required).toEqual(['operation']);
+    });
+
+    it('should disallow additional properties', () => {
+      expect(resourcesTool.parameters.additionalProperties).toBe(false);
+    });
+
+    it('should have descriptions for all parameters', () => {
+      const props = resourcesTool.parameters.properties;
+      for (const [key, value] of Object.entries(props)) {
+        if (key !== 'operation') {
+          expect((value as any).description, `${key} should have a description`).toBeTruthy();
+        }
+      }
+    });
+  });
+});

package/src/resources-tool.ts

@@ -0,0 +1,77 @@
+import type { MCPTool } from './tasks-tool.js'
+
+export const resourcesTool: MCPTool = {
+  name: 'resources',
+  description: 'Manage media resources: generate images, audio, and video via AI, save files from URLs, and browse existing resources. Generation operations auto-save to the resource library with thumbnails.',
+  parameters: {
+    type: 'object',
+    properties: {
+      operation: {
+        type: 'string',
+        enum: ['list', 'get', 'generate_image', 'generate_audio', 'generate_video', 'add_from_url'],
+        description: 'The resource operation to execute'
+      },
+      // READ params
+      query: {
+        type: 'string',
+        description: 'Search filter for list operation — matches name, description, or tags'
+      },
+      type_filter: {
+        type: 'string',
+        description: 'Filter by media type prefix for list operation (e.g. "image", "audio", "video")'
+      },
+      resource_id: {
+        type: 'string',
+        description: 'Resource ID for get operation (e.g. "res-1234567890-abc123def")'
+      },
+      // generate_image params
+      prompt: {
+        type: 'string',
+        description: 'Text prompt describing the image or video to generate'
+      },
+      model: {
+        type: 'string',
+        enum: ['nano-banana-pro', 'flux-2-dev', 'flux-2-pro', 'gpt-image-1.5'],
+        description: 'AI model for image generation. Default: nano-banana-pro. Use gpt-image-1.5 for transparent backgrounds.'
+      },
+      aspect_ratio: {
+        type: 'string',
+        description: 'Aspect ratio for image/video (e.g. "1:1", "16:9", "9:16", "4:3", "3:2"). Default: 16:9 for images, 16:9 for video.'
+      },
+      // generate_audio params
+      text: {
+        type: 'string',
+        description: 'Text to convert to speech for audio generation'
+      },
+      voice: {
+        type: 'string',
+        description: 'Voice ID for audio generation. Default: English_Trustworth_Man'
+      },
+      // generate_video params (prompt is reused)
+      duration: {
+        type: 'number',
+        description: 'Video duration in seconds, 5-16. Default: 8'
+      },
+      resolution: {
+        type: 'string',
+        description: 'Video resolution (480p, 720p, 1080p). Default: 720p'
+      },
+      // add_from_url params
+      url: {
+        type: 'string',
+        description: 'URL to download and save as a resource'
+      },
+      // Shared metadata
+      tags: {
+        type: 'string',
+        description: 'Comma-separated tags for the resource'
+      },
+      description: {
+        type: 'string',
+        description: 'Description of the resource'
+      }
+    },
+    required: ['operation'],
+    additionalProperties: false
+  }
+}

package/src/role-context-tool.ts

@@ -3,7 +3,7 @@
  * Allows the AI assistant to read and update the role definition document (.nut/context/role.md)
  */
 
-import type { MCPTool } from './proposals-tool.js'
+import type { MCPTool } from './tasks-tool.js'
 
 /**
  * Role context tool for AI assistant.

package/src/tasks-tool.test.ts

@@ -0,0 +1,139 @@
+/**
+ * Tests for tasks tool utilities
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  validateTaskData,
+  createToolCall,
+  listTasksTool,
+  tasksTool,
+  tasksReadOnlyTool,
+  tasksFullTool,
+} from './tasks-tool.js';
+
+describe('validateTaskData', () => {
+  it('should extract intent and content', () => {
+    const result = validateTaskData({
+      intent: 'Add dark mode',
+      content: 'Implement dark mode toggle',
+    });
+    expect(result.intent).toBe('Add dark mode');
+    expect(result.content).toBe('Implement dark mode toggle');
+  });
+
+  it('should extract all supported fields', () => {
+    const result = validateTaskData({
+      intent: 'Test',
+      content: 'Body',
+      author: 'engineer',
+      planSteps: ['step1'],
+      status: 'draft',
+      metadata: { foo: 'bar' },
+    });
+    expect(result.intent).toBe('Test');
+    expect(result.content).toBe('Body');
+    expect(result.author).toBe('engineer');
+    expect(result.planSteps).toEqual(['step1']);
+    expect(result.status).toBe('draft');
+    expect(result.metadata).toEqual({ foo: 'bar' });
+  });
+
+  it('should return empty object for empty input', () => {
+    const result = validateTaskData({});
+    expect(result).toEqual({});
+  });
+
+  it('should ignore unknown fields', () => {
+    const result = validateTaskData({
+      intent: 'Test',
+      unknownField: 'ignored',
+    });
+    expect(result.intent).toBe('Test');
+    expect((result as any).unknownField).toBeUndefined();
+  });
+});
+
+describe('createToolCall', () => {
+  it('should create tool call with operation and args', () => {
+    const call = createToolCall('list', { filters: { status: 'draft' } });
+    expect(call.name).toBe('tasks');
+    expect(call.arguments).toEqual({
+      operation: 'list',
+      filters: { status: 'draft' },
+    });
+  });
+
+  it('should create tool call for get operation', () => {
+    const call = createToolCall('get', { id: 'cp-123' });
+    expect(call.name).toBe('tasks');
+    expect(call.arguments).toEqual({
+      operation: 'get',
+      id: 'cp-123',
+    });
+  });
+
+  it('should merge operation with spread args', () => {
+    const call = createToolCall('create', { task: { intent: 'Test' } });
+    expect(call.arguments.operation).toBe('create');
+    expect(call.arguments.task).toEqual({ intent: 'Test' });
+  });
+});
+
+describe('tasks tools', () => {
+  it('should have listTasksTool with correct structure', () => {
+    expect(listTasksTool.name).toBe('list_tasks');
+    expect(listTasksTool.parameters.type).toBe('object');
+    expect(listTasksTool.parameters.properties.filters).toBeDefined();
+  });
+
+  it('should have tasksTool with list, get, create, update, delete operations', () => {
+    expect(tasksTool.name).toBe('tasks');
+    const ops = tasksTool.parameters.properties.operation.enum;
+    expect(ops).toContain('list');
+    expect(ops).toContain('get');
+    expect(ops).toContain('create');
+    expect(ops).toContain('update');
+    expect(ops).toContain('delete');
+  });
+
+  it('should have tasksReadOnlyTool with only list and get', () => {
+    const ops = tasksReadOnlyTool.parameters.properties.operation.enum;
+    expect(ops).toEqual(['list', 'get']);
+  });
+
+  it('should have tasksFullTool with task and updates', () => {
+    expect(tasksFullTool.parameters.properties.task).toBeDefined();
+    expect(tasksFullTool.parameters.properties.updates).toBeDefined();
+  });
+
+  it('should mention summaries in tool descriptions to clarify list returns lightweight data', () => {
+    expect(tasksFullTool.description).toContain('summaries');
+    expect(tasksTool.description).toContain('summaries');
+    expect(tasksReadOnlyTool.description).toContain('summaries');
+  });
+
+  it('should mention using get for full details in tool descriptions', () => {
+    expect(tasksFullTool.description).toContain('get');
+    expect(tasksTool.description).toContain('get');
+    expect(tasksReadOnlyTool.description).toContain('get');
+  });
+
+  it('should mention default limit in filters description', () => {
+    expect(tasksFullTool.parameters.properties.filters.description).toContain('limit=20');
+    expect(tasksTool.parameters.properties.filters.description).toContain('limit=20');
+    expect(tasksReadOnlyTool.parameters.properties.filters.description).toContain('limit=20');
+  });
+
+  it('should expose limit in the filters properties via JSON schema', () => {
+    // Verify that the auto-generated filter properties include a limit field
+    const fullFilters = tasksFullTool.parameters.properties.filters.properties;
+    expect(fullFilters).toHaveProperty('limit');
+
+    const readOnlyFilters = tasksReadOnlyTool.parameters.properties.filters.properties;
+    expect(readOnlyFilters).toHaveProperty('limit');
+
+    const standardFilters = tasksTool.parameters.properties.filters.properties;
+    expect(standardFilters).toHaveProperty('limit');
+  });
+});

package/src/tasks-tool.ts

@@ -0,0 +1,170 @@
+import type { Task } from '@lovelybunch/types'
+import { taskJsonSchemas } from '@lovelybunch/core'
+
+export interface MCPTool {
+  name: string
+  description: string
+  parameters: {
+    type: 'object'
+    properties: Record<string, any>
+    required?: string[]
+    additionalProperties?: boolean
+  }
+}
+
+export interface MCPToolCall {
+  name: string
+  arguments: Record<string, any>
+}
+
+// Use pre-computed JSON schemas from core
+const filtersProperties = taskJsonSchemas.filters
+const createProperties = taskJsonSchemas.create
+const updateProperties = taskJsonSchemas.update
+const createRequired = taskJsonSchemas.createRequired
+
+export const listTasksTool: MCPTool = {
+  name: "list_tasks",
+  description: "List all tasks with metadata only (title, ID, status, priority, tags)",
+  parameters: {
+    type: "object",
+    properties: {
+      filters: {
+        type: "object",
+        description: "Optional filters for the task list",
+        properties: filtersProperties
+      }
+    }
+  }
+}
+
+export const tasksTool: MCPTool = {
+  name: "tasks",
+  description: "Manage tasks - create, read, update, delete tasks. IMPORTANT: When searching for tasks by topic or keyword, always use filters.search to filter results server-side. The 'list' operation returns lightweight summaries — use 'get' with a task ID for full details.",
+  parameters: {
+    type: "object",
+    properties: {
+      operation: {
+        type: "string",
+        enum: ["list", "get", "create", "update", "delete"],
+        description: "The operation to perform on tasks"
+      },
+      id: {
+        type: "string",
+        description: "Task ID (required for get, update, delete operations)"
+      },
+      // Filters for list operation - auto-generated from Zod schema
+      filters: {
+        type: "object",
+        description: "Filters for list operation. Defaults to limit=20. Use search to find tasks by keyword — results are filtered server-side for accuracy.",
+        properties: filtersProperties
+      },
+      // Task data for create operation - auto-generated from Zod schema
+      task: {
+        type: "object",
+        description: "Task data for create/update operations. For create: intent and content are required. For update: at least one field is required.",
+        properties: createProperties,
+        required: [...createRequired]
+      }
+    },
+    required: ["operation"]
+  }
+}
+
+/**
+ * Read-only version of the tasks tool for AI assistant.
+ * Only exposes list and get operations - no create/update/delete.
+ * Creating tasks should be done by coding agents (Claude Code, Cursor, etc.) or via the UI.
+ */
+export const tasksReadOnlyTool: MCPTool = {
+  name: "tasks",
+  description: "READ-ONLY: Search and read tasks. You can ONLY use 'list' and 'get' operations. You CANNOT create, update, or delete tasks — that should be done by coding agents (Claude Code, Cursor, etc.) which have broader codebase context, or via the Tasks UI. The 'list' operation returns lightweight summaries — use 'get' with a task ID for full details.",
+  parameters: {
+    type: "object",
+    properties: {
+      operation: {
+        type: "string",
+        enum: ["list", "get"],
+        description: "ONLY 'list' or 'get' are allowed. 'list' to search/browse tasks (returns summaries), 'get' to retrieve a specific task by ID (returns full details)"
+      },
+      id: {
+        type: "string",
+        description: "Task ID (required for get operation)"
+      },
+      // Filters auto-generated from Zod schema
+      filters: {
+        type: "object",
+        description: "Filters for list operation. Defaults to limit=20. Use search to find tasks by keyword.",
+        properties: filtersProperties
+      }
+    },
+    required: ["operation"]
+  }
+}
+
+/**
+ * Full CRUD tasks tool that includes create and update operations.
+ * Uses Zod schemas for validation.
+ */
+export const tasksFullTool: MCPTool = {
+  name: "tasks",
+  description: "Full CRUD for tasks - create, read, update, delete. Use this when you need to create or modify tasks via MCP. The 'list' operation returns lightweight summaries (id, title, status, priority, tags, author, dates) — use 'get' with a specific task ID to retrieve full task details including content and plan steps.",
+  parameters: {
+    type: "object",
+    properties: {
+      operation: {
+        type: "string",
+        enum: ["list", "get", "create", "update", "delete"],
+        description: "The operation to perform"
+      },
+      id: {
+        type: "string",
+        description: "Task ID (required for get, update, delete operations)"
+      },
+      filters: {
+        type: "object",
+        description: "Filters for list operation. Defaults to limit=20. Use status, priority, tags, search, or author to narrow results.",
+        properties: filtersProperties
+      },
+      // For create - all fields from CreateTaskInputSchema
+      task: {
+        type: "object",
+        description: "Task data for create operation",
+        properties: createProperties,
+        required: [...createRequired]
+      },
+      // For update - partial fields from UpdateTaskInputSchema
+      updates: {
+        type: "object",
+        description: "Fields to update (for update operation). At least one field required.",
+        properties: updateProperties
+      }
+    },
+    required: ["operation"]
+  }
+}
+
+export function validateTaskData(data: any): Partial<Task> {
+  const task: Partial<Task> = {}
+  
+  if (data.title) task.title = data.title
+  if (data.intent) task.intent = data.intent
+  if (data.content) task.content = data.content
+  if (data.author) task.author = data.author
+  if (data.planSteps) task.planSteps = data.planSteps
+  if (data.status) task.status = data.status
+  if (data.metadata) task.metadata = data.metadata
+  if (data.productSpecRef) task.productSpecRef = data.productSpecRef
+  
+  return task
+}
+
+export function createToolCall(operation: string, args: any): MCPToolCall {
+  return {
+    name: "tasks",
+    arguments: {
+      operation,
+      ...args
+    }
+  }
+}

package/src/proposals-tool.test.ts

@@ -1,109 +0,0 @@
-/**
- * Tests for proposals tool utilities
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  validateProposalData,
-  createToolCall,
-  listProposalsTool,
-  proposalsTool,
-  proposalsReadOnlyTool,
-  proposalsFullTool,
-} from './proposals-tool.js';
-
-describe('validateProposalData', () => {
-  it('should extract intent and content', () => {
-    const result = validateProposalData({
-      intent: 'Add dark mode',
-      content: 'Implement dark mode toggle',
-    });
-    expect(result.intent).toBe('Add dark mode');
-    expect(result.content).toBe('Implement dark mode toggle');
-  });
-
-  it('should extract all supported fields', () => {
-    const result = validateProposalData({
-      intent: 'Test',
-      content: 'Body',
-      author: 'engineer',
-      planSteps: ['step1'],
-      status: 'draft',
-      metadata: { foo: 'bar' },
-    });
-    expect(result.intent).toBe('Test');
-    expect(result.content).toBe('Body');
-    expect(result.author).toBe('engineer');
-    expect(result.planSteps).toEqual(['step1']);
-    expect(result.status).toBe('draft');
-    expect(result.metadata).toEqual({ foo: 'bar' });
-  });
-
-  it('should return empty object for empty input', () => {
-    const result = validateProposalData({});
-    expect(result).toEqual({});
-  });
-
-  it('should ignore unknown fields', () => {
-    const result = validateProposalData({
-      intent: 'Test',
-      unknownField: 'ignored',
-    });
-    expect(result.intent).toBe('Test');
-    expect((result as any).unknownField).toBeUndefined();
-  });
-});
-
-describe('createToolCall', () => {
-  it('should create tool call with operation and args', () => {
-    const call = createToolCall('list', { filters: { status: 'draft' } });
-    expect(call.name).toBe('change_proposals');
-    expect(call.arguments).toEqual({
-      operation: 'list',
-      filters: { status: 'draft' },
-    });
-  });
-
-  it('should create tool call for get operation', () => {
-    const call = createToolCall('get', { id: 'cp-123' });
-    expect(call.name).toBe('change_proposals');
-    expect(call.arguments).toEqual({
-      operation: 'get',
-      id: 'cp-123',
-    });
-  });
-
-  it('should merge operation with spread args', () => {
-    const call = createToolCall('create', { proposal: { intent: 'Test' } });
-    expect(call.arguments.operation).toBe('create');
-    expect(call.arguments.proposal).toEqual({ intent: 'Test' });
-  });
-});
-
-describe('proposals tools', () => {
-  it('should have listProposalsTool with correct structure', () => {
-    expect(listProposalsTool.name).toBe('list_proposals');
-    expect(listProposalsTool.parameters.type).toBe('object');
-    expect(listProposalsTool.parameters.properties.filters).toBeDefined();
-  });
-
-  it('should have proposalsTool with list, get, create, update, delete operations', () => {
-    expect(proposalsTool.name).toBe('change_proposals');
-    const ops = proposalsTool.parameters.properties.operation.enum;
-    expect(ops).toContain('list');
-    expect(ops).toContain('get');
-    expect(ops).toContain('create');
-    expect(ops).toContain('update');
-    expect(ops).toContain('delete');
-  });
-
-  it('should have proposalsReadOnlyTool with only list and get', () => {
-    const ops = proposalsReadOnlyTool.parameters.properties.operation.enum;
-    expect(ops).toEqual(['list', 'get']);
-  });
-
-  it('should have proposalsFullTool with create and updates', () => {
-    expect(proposalsFullTool.parameters.properties.proposal).toBeDefined();
-    expect(proposalsFullTool.parameters.properties.updates).toBeDefined();
-  });
-});