@lovelybunch/mcp 1.0.62 → 1.0.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovelybunch/mcp",
-  "version": "1.0.62",
+  "version": "1.0.63",
   "description": "MCP tools for Coconut",
   "main": "dist/index.js",
   "type": "module",
@@ -9,7 +9,7 @@
     "dev": "tsc --watch"
   },
   "dependencies": {
-    "@lovelybunch/types": "^1.0.62",
+    "@lovelybunch/types": "^1.0.63",
     "hono": "^4.0.0"
   },
   "devDependencies": {

package/dist/server.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/server.js

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-import { createInterface } from 'readline';
-import { stdin as input, stdout as output } from 'process';
-import fs from 'fs';
-import path from 'path';
-function send(id, result, error) {
-    const payload = { jsonrpc: '2.0', id };
-    if (error)
-        payload.error = error;
-    else
-        payload.result = result;
-    output.write(JSON.stringify(payload) + '\n');
-}
-function resolveNutPath() {
-    if (process.env.GAIT_DATA_PATH)
-        return path.join(process.env.GAIT_DATA_PATH, '.nut');
-    // Try to find nearest .nut folder upward from cwd
-    let dir = process.cwd();
-    for (;;) {
-        const p = path.join(dir, '.nut');
-        if (fs.existsSync(p))
-            return p;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            break;
-        dir = parent;
-    }
-    return path.join(process.cwd(), '.nut');
-}
-function listProposalFiles() {
-    const base = resolveNutPath();
-    const p = path.join(base, 'proposals');
-    try {
-        return fs.readdirSync(p).filter((f) => f.endsWith('.md'));
-    }
-    catch {
-        return [];
-    }
-}
-function readProposal(id) {
-    const base = resolveNutPath();
-    const fp = path.join(base, 'proposals', `${id}.md`);
-    try {
-        const content = fs.readFileSync(fp, 'utf-8');
-        // Naive frontmatter parse (best effort, no YAML dependency)
-        let frontmatter;
-        if (content.startsWith('---')) {
-            const end = content.indexOf('\n---', 3);
-            if (end > 0) {
-                const fm = content.slice(3, end).split('\n');
-                frontmatter = {};
-                for (const line of fm) {
-                    const m = /^([A-Za-z0-9_\-]+):\s*(.*)$/.exec(line.trim());
-                    if (m)
-                        frontmatter[m[1]] = m[2];
-                }
-            }
-        }
-        return { content, frontmatter };
-    }
-    catch {
-        return null;
-    }
-}
-const tools = [
-    {
-        name: 'list_proposals',
-        description: 'List all change proposals with basic metadata',
-        input_schema: {
-            type: 'object',
-            properties: {
-                filters: { type: 'object' },
-            },
-        },
-    },
-    {
-        name: 'change_proposals',
-        description: 'Manage change proposals (list, get)',
-        input_schema: {
-            type: 'object',
-            properties: {
-                operation: { type: 'string', enum: ['list', 'get'] },
-                id: { type: 'string' },
-                filters: { type: 'object' },
-            },
-            required: ['operation'],
-        },
-    },
-];
-async function handleCall(params) {
-    const name = params?.name || params?.tool?.name;
-    const args = params?.arguments || params?.tool?.input || {};
-    switch (name) {
-        case 'list_proposals': {
-            const files = listProposalFiles();
-            const data = files.map((f) => ({ id: f.replace(/\.md$/, ''), title: f.replace(/\.md$/, '') }));
-            return { success: true, data, message: `Found ${data.length} proposals` };
-        }
-        case 'change_proposals': {
-            const op = args.operation;
-            if (op === 'list') {
-                const files = listProposalFiles();
-                const data = files.map((f) => ({ id: f.replace(/\.md$/, ''), title: f.replace(/\.md$/, '') }));
-                return { success: true, data, message: `Found ${data.length} proposals` };
-            }
-            if (op === 'get') {
-                if (!args.id)
-                    return { success: false, error: 'Proposal ID required' };
-                const p = readProposal(args.id);
-                if (!p)
-                    return { success: false, error: 'Proposal not found' };
-                return { success: true, data: { id: args.id, content: p.content, frontmatter: p.frontmatter || {} } };
-            }
-            return { success: false, error: 'Operation not implemented' };
-        }
-        default:
-            return { success: false, error: 'Unknown tool' };
-    }
-}
-function start() {
-    const rl = createInterface({ input });
-    rl.on('line', async (line) => {
-        let msg;
-        try {
-            msg = JSON.parse(line);
-        }
-        catch {
-            return; // ignore invalid JSON
-        }
-        const { id, method, params } = msg || {};
-        try {
-            if (method === 'initialize') {
-                send(id, {
-                    serverInfo: { name: '@lovelybunch/mcp-proposals', version: '1.0.0' },
-                    capabilities: { tools: {} },
-                });
-                return;
-            }
-            if (method === 'tools/list') {
-                send(id, { tools });
-                return;
-            }
-            if (method === 'tools/call') {
-                const result = await handleCall(params);
-                send(id, { content: [{ type: 'text', text: JSON.stringify(result) }] });
-                return;
-            }
-            send(id, undefined, { code: -32601, message: 'Method not found' });
-        }
-        catch (e) {
-            send(id, undefined, { code: -32000, message: e?.message || 'Server error' });
-        }
-    });
-}
-start();

package/dist/src/index.d.ts

@@ -1,3 +0,0 @@
-export { proposalsTool, listProposalsTool, validateProposalData, createToolCall } from './proposals-tool.js';
-export { knowledgeTool, createKnowledgeToolCall, normalizeKnowledgeMetadata, buildKnowledgeActionPayload } from './knowledge-tool.js';
-export type { MCPTool, MCPToolCall } from './proposals-tool.js';

package/dist/src/index.js

@@ -1,2 +0,0 @@
-export { proposalsTool, listProposalsTool, validateProposalData, createToolCall } from './proposals-tool.js';
-export { knowledgeTool, createKnowledgeToolCall, normalizeKnowledgeMetadata, buildKnowledgeActionPayload } from './knowledge-tool.js';

package/dist/src/knowledge-tool.d.ts

@@ -1,6 +0,0 @@
-import type { KnowledgeActionPayload, KnowledgeDocumentMetadata } from '@lovelybunch/types';
-import type { MCPTool, MCPToolCall } from './proposals-tool.js';
-export declare const knowledgeTool: MCPTool;
-export declare function createKnowledgeToolCall(operation: string, args: Record<string, unknown>): MCPToolCall;
-export declare function normalizeKnowledgeMetadata(metadata?: KnowledgeDocumentMetadata | null): KnowledgeDocumentMetadata;
-export declare function buildKnowledgeActionPayload(input: KnowledgeActionPayload): KnowledgeActionPayload;

package/dist/src/knowledge-tool.js

@@ -1,85 +0,0 @@
-const metadataSchema = {
-    type: 'object',
-    description: 'Frontmatter metadata to persist alongside the knowledge document',
-    properties: {
-        version: { type: 'string', description: 'Semantic version of the knowledge document' },
-        updated: { type: 'string', description: 'ISO date override for last updated (defaults to today if omitted)' },
-        type: { type: 'string', description: 'Document type, defaults to knowledge' },
-        category: { type: 'string', description: 'High-level category for grouping documents' },
-        tags: { type: 'array', items: { type: 'string' }, description: 'Keyword tags to aid discovery' },
-        sources: { type: 'array', items: { type: 'string' }, description: 'URLs or references that informed this knowledge' },
-        related: { type: 'array', items: { type: 'string' }, description: 'Paths to related docs (e.g. proposals, specs)' },
-        owner: {
-            type: 'object',
-            properties: {
-                name: { type: 'string' },
-                email: { type: 'string' }
-            },
-            additionalProperties: false
-        },
-        audience: { type: 'array', items: { type: 'string' }, description: 'Intended readers (roles, teams)' },
-        status: { type: 'string', description: 'Lifecycle status (draft, active, deprecated, etc.)' }
-    },
-    additionalProperties: true
-};
-export const knowledgeTool = {
-    name: 'knowledge_documents',
-    description: 'Manage knowledge base markdown documents stored in .nut/context/knowledge',
-    parameters: {
-        type: 'object',
-        properties: {
-            operation: {
-                type: 'string',
-                enum: ['list', 'get', 'create', 'update', 'preview_update'],
-                description: 'The knowledge document operation to execute'
-            },
-            filename: {
-                type: 'string',
-                description: 'Existing knowledge filename (with or without .md) for get/update/preview operations'
-            },
-            title: {
-                type: 'string',
-                description: 'Human readable title for the knowledge document (used to derive filename on create)'
-            },
-            content: {
-                type: 'string',
-                description: 'Markdown body for the knowledge document. Required for create/update/preview operations.'
-            },
-            summary: {
-                type: 'string',
-                description: 'Short description of the change. Helpful when presenting updates to the user.'
-            },
-            metadata: metadataSchema
-        },
-        required: ['operation'],
-        additionalProperties: false
-    }
-};
-export function createKnowledgeToolCall(operation, args) {
-    return {
-        name: 'knowledge_documents',
-        arguments: {
-            operation,
-            ...args
-        }
-    };
-}
-export function normalizeKnowledgeMetadata(metadata) {
-    const baseDate = new Date().toISOString().split('T')[0];
-    return {
-        type: 'knowledge',
-        updated: baseDate,
-        ...metadata,
-        tags: metadata?.tags ? [...metadata.tags] : [],
-        sources: metadata?.sources ? [...metadata.sources] : [],
-        related: metadata?.related ? [...metadata.related] : [],
-        audience: metadata?.audience ? [...metadata.audience] : []
-    };
-}
-export function buildKnowledgeActionPayload(input) {
-    const metadata = input.metadata ? normalizeKnowledgeMetadata(input.metadata) : undefined;
-    return {
-        ...input,
-        metadata
-    };
-}

package/dist/src/proposals-tool.d.ts

@@ -1,19 +0,0 @@
-import type { ChangeProposal } from '@lovelybunch/types';
-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>;
-}
-export declare const listProposalsTool: MCPTool;
-export declare const proposalsTool: MCPTool;
-export declare function validateProposalData(data: any): Partial<ChangeProposal>;
-export declare function createToolCall(operation: string, args: any): MCPToolCall;

package/dist/src/proposals-tool.js

@@ -1,232 +0,0 @@
-export const listProposalsTool = {
-    name: "list_proposals",
-    description: "List all change proposals with metadata only (title, ID, status, priority, tags)",
-    parameters: {
-        type: "object",
-        properties: {
-            filters: {
-                type: "object",
-                description: "Optional filters for the proposal list",
-                properties: {
-                    status: {
-                        type: "string",
-                        enum: ["draft", "proposed", "in-review", "code-complete", "approved", "merged", "rejected"],
-                        description: "Filter by proposal status"
-                    },
-                    priority: {
-                        type: "string",
-                        enum: ["low", "medium", "high", "critical"],
-                        description: "Filter by priority level"
-                    },
-                    tags: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Filter by tags"
-                    },
-                    search: {
-                        type: "string",
-                        description: "Search query for proposal content"
-                    }
-                }
-            }
-        }
-    }
-};
-export const proposalsTool = {
-    name: "change_proposals",
-    description: "Manage change proposals - create, read, update, delete proposals",
-    parameters: {
-        type: "object",
-        properties: {
-            operation: {
-                type: "string",
-                enum: ["list", "get", "create", "update", "delete"],
-                description: "The operation to perform on proposals"
-            },
-            id: {
-                type: "string",
-                description: "Proposal ID (required for get, update, delete operations)"
-            },
-            filters: {
-                type: "object",
-                description: "Filters for list operation",
-                properties: {
-                    status: {
-                        type: "string",
-                        enum: ["draft", "proposed", "in-review", "code-complete", "approved", "merged", "rejected"],
-                        description: "Filter by proposal status"
-                    },
-                    author: {
-                        type: "string",
-                        description: "Filter by author name or email"
-                    },
-                    priority: {
-                        type: "string",
-                        enum: ["low", "medium", "high", "critical"],
-                        description: "Filter by priority level"
-                    },
-                    tags: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Filter by tags"
-                    },
-                    search: {
-                        type: "string",
-                        description: "Search query for proposal content"
-                    }
-                }
-            },
-            proposal: {
-                type: "object",
-                description: "Proposal data for create/update operations",
-                properties: {
-                    intent: {
-                        type: "string",
-                        description: "Brief description of what the proposal aims to achieve"
-                    },
-                    content: {
-                        type: "string",
-                        description: "Detailed content of the proposal"
-                    },
-                    author: {
-                        type: "object",
-                        description: "Author information",
-                        properties: {
-                            id: { type: "string" },
-                            name: { type: "string" },
-                            email: { type: "string" },
-                            role: { type: "string" },
-                            type: { type: "string", enum: ["human", "agent"] }
-                        }
-                    },
-                    planSteps: {
-                        type: "array",
-                        description: "Implementation plan steps. Each item may be a string (description) or an object with fields.",
-                        items: {
-                            oneOf: [
-                                { type: "string", description: "Step description" },
-                                {
-                                    type: "object",
-                                    properties: {
-                                        id: { type: "string", description: "Step identifier (optional)" },
-                                        description: { type: "string", description: "Human-readable step description" },
-                                        status: { type: "string", enum: ["pending", "in-progress", "completed", "failed"], description: "Execution status" },
-                                        command: { type: "string", description: "Optional command to execute" },
-                                        expectedOutcome: { type: "string", description: "Expected outcome of the step" }
-                                    },
-                                    required: ["description"]
-                                }
-                            ]
-                        }
-                    },
-                    evidence: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Supporting evidence"
-                    },
-                    policies: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Related policies"
-                    },
-                    featureFlags: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Feature flags needed"
-                    },
-                    experiments: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "A/B tests or experiments"
-                    },
-                    telemetryContracts: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Telemetry contracts"
-                    },
-                    releasePlan: {
-                        type: "object",
-                        description: "Release strategy",
-                        properties: {
-                            strategy: {
-                                type: "string",
-                                enum: ["immediate", "gradual", "scheduled", "gated"]
-                            }
-                        }
-                    },
-                    status: {
-                        type: "string",
-                        enum: ["draft", "proposed", "in-review", "code-complete", "approved", "merged", "rejected"],
-                        description: "Current status of the proposal"
-                    },
-                    metadata: {
-                        type: "object",
-                        description: "Additional metadata",
-                        properties: {
-                            tags: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "Tags for categorization"
-                            },
-                            priority: {
-                                type: "string",
-                                enum: ["low", "medium", "high", "critical"],
-                                description: "Priority level"
-                            },
-                            reviewers: {
-                                type: "array",
-                                items: { type: "string" },
-                                description: "List of reviewers"
-                            }
-                        }
-                    },
-                    productSpecRef: {
-                        type: "string",
-                        description: "Reference to related product specification"
-                    }
-                },
-                required: ["intent", "content"]
-            }
-        },
-        required: ["operation"]
-    }
-};
-export function validateProposalData(data) {
-    const proposal = {};
-    if (data.intent)
-        proposal.intent = data.intent;
-    if (data.content)
-        proposal.content = data.content;
-    if (data.author)
-        proposal.author = data.author;
-    if (data.planSteps)
-        proposal.planSteps = data.planSteps;
-    if (data.evidence)
-        proposal.evidence = data.evidence;
-    if (data.policies)
-        proposal.policies = data.policies;
-    if (data.featureFlags)
-        proposal.featureFlags = data.featureFlags;
-    if (data.experiments)
-        proposal.experiments = data.experiments;
-    if (data.telemetryContracts)
-        proposal.telemetryContracts = data.telemetryContracts;
-    if (data.releasePlan)
-        proposal.releasePlan = data.releasePlan;
-    if (data.status)
-        proposal.status = data.status;
-    if (data.metadata)
-        proposal.metadata = data.metadata;
-    if (data.productSpecRef)
-        proposal.productSpecRef = data.productSpecRef;
-    return proposal;
-}
-export function createToolCall(operation, args) {
-    return {
-        name: "change_proposals",
-        arguments: {
-            operation,
-            ...args
-        }
-    };
-}