latitude-mcp-server 1.0.0

package/dist/controllers/latitude.controller.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger_util_js_1 = require("../utils/logger.util.js");
+const vendor_latitude_service_js_1 = __importDefault(require("../services/vendor.latitude.service.js"));
+const error_handler_util_js_1 = require("../utils/error-handler.util.js");
+const jq_util_js_1 = require("../utils/jq.util.js");
+/**
+ * Derive prompt path from filename
+ * e.g., "/path/to/my-prompt.md" → "my-prompt"
+ */
+function derivePromptPath(filePath) {
+    const base = (0, path_1.basename)(filePath);
+    const ext = (0, path_1.extname)(base);
+    // Remove .md, .promptl, .txt extensions
+    if (['.md', '.promptl', '.txt'].includes(ext)) {
+        return base.slice(0, -ext.length);
+    }
+    return base;
+}
+/**
+ * Format output data consistently
+ */
+async function formatOutput(data, options = {}) {
+    const filteredData = (0, jq_util_js_1.applyJqFilter)(data, options.jq);
+    const useToon = options.outputFormat !== 'json';
+    const content = await (0, jq_util_js_1.toOutputString)(filteredData, useToon);
+    return { content };
+}
+// ============================================================================
+// Projects Controller
+// ============================================================================
+async function listProjects(options = {}) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'listProjects');
+    methodLogger.debug('Listing all projects');
+    try {
+        const projects = await vendor_latitude_service_js_1.default.listProjects();
+        return formatOutput(projects, options);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'listProjects', 'controllers/latitude.controller.ts@listProjects', 'projects', {}));
+    }
+}
+async function createProject(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'createProject');
+    methodLogger.debug(`Creating project: ${args.name}`);
+    try {
+        const project = await vendor_latitude_service_js_1.default.createProject(args.name);
+        return formatOutput(project, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'createProject', 'controllers/latitude.controller.ts@createProject', args.name, { args }));
+    }
+}
+// ============================================================================
+// Versions Controller
+// ============================================================================
+async function listVersions(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'listVersions');
+    methodLogger.debug(`Listing versions for project: ${args.projectId}`);
+    try {
+        const versions = await vendor_latitude_service_js_1.default.listVersions(args.projectId);
+        return formatOutput(versions, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'listVersions', 'controllers/latitude.controller.ts@listVersions', args.projectId, { args }));
+    }
+}
+async function getVersion(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'getVersion');
+    methodLogger.debug(`Getting version: ${args.versionUuid}`);
+    try {
+        const version = await vendor_latitude_service_js_1.default.getVersion(args.projectId, args.versionUuid);
+        return formatOutput(version, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'getVersion', 'controllers/latitude.controller.ts@getVersion', args.versionUuid, { args }));
+    }
+}
+async function createVersion(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'createVersion');
+    methodLogger.debug(`Creating version: ${args.name}`);
+    try {
+        const version = await vendor_latitude_service_js_1.default.createVersion(args.projectId, args.name);
+        return formatOutput(version, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'createVersion', 'controllers/latitude.controller.ts@createVersion', args.name, { args }));
+    }
+}
+async function publishVersion(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'publishVersion');
+    methodLogger.debug(`Publishing version: ${args.versionUuid}`);
+    try {
+        const version = await vendor_latitude_service_js_1.default.publishVersion(args.projectId, args.versionUuid, { title: args.title, description: args.description });
+        return formatOutput(version, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'publishVersion', 'controllers/latitude.controller.ts@publishVersion', args.versionUuid, { args }));
+    }
+}
+async function pushChanges(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'pushChanges');
+    methodLogger.debug(`Pushing ${args.changes.length} changes`);
+    try {
+        const result = await vendor_latitude_service_js_1.default.pushChanges(args.projectId, args.versionUuid, { changes: args.changes });
+        return formatOutput(result, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'pushChanges', 'controllers/latitude.controller.ts@pushChanges', args.versionUuid, { args }));
+    }
+}
+// ============================================================================
+// Documents/Prompts Controller
+// ============================================================================
+async function listPrompts(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'listPrompts');
+    methodLogger.debug(`Listing prompts for version: ${args.versionUuid}`);
+    try {
+        const documents = await vendor_latitude_service_js_1.default.listDocuments(args.projectId, args.versionUuid);
+        return formatOutput(documents, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'listPrompts', 'controllers/latitude.controller.ts@listPrompts', args.versionUuid, { args }));
+    }
+}
+async function getPrompt(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'getPrompt');
+    methodLogger.debug(`Getting prompt: ${args.path}`);
+    try {
+        const document = await vendor_latitude_service_js_1.default.getDocument(args.projectId, args.versionUuid, args.path);
+        return formatOutput(document, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'getPrompt', 'controllers/latitude.controller.ts@getPrompt', args.path, { args }));
+    }
+}
+async function pushPrompt(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'pushPrompt');
+    methodLogger.debug(`Pushing prompt: ${args.path}`);
+    try {
+        const document = await vendor_latitude_service_js_1.default.createOrUpdateDocument(args.projectId, args.versionUuid, args.path, args.content, args.force);
+        return formatOutput(document, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'pushPrompt', 'controllers/latitude.controller.ts@pushPrompt', args.path, { args }));
+    }
+}
+async function pushPromptFromFile(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'pushPromptFromFile');
+    // Resolve and validate file path
+    const absolutePath = (0, path_1.resolve)(args.filePath);
+    if (!(0, fs_1.existsSync)(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+    }
+    // Read file content
+    const content = (0, fs_1.readFileSync)(absolutePath, 'utf-8');
+    // Derive prompt path from filename if not provided
+    const promptPath = args.promptPath || derivePromptPath(args.filePath);
+    methodLogger.debug(`Pushing prompt from file: ${absolutePath} → ${promptPath}`);
+    try {
+        const document = await vendor_latitude_service_js_1.default.createOrUpdateDocument(args.projectId, args.versionUuid, promptPath, content, args.force);
+        // Include file info in response
+        const result = {
+            ...document,
+            _meta: {
+                sourceFile: absolutePath,
+                promptPath,
+                contentLength: content.length,
+            },
+        };
+        return formatOutput(result, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'pushPromptFromFile', 'controllers/latitude.controller.ts@pushPromptFromFile', absolutePath, { args }));
+    }
+}
+async function runPrompt(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'runPrompt');
+    methodLogger.debug(`Running prompt: ${args.path}`);
+    try {
+        const result = await vendor_latitude_service_js_1.default.runDocument(args.projectId, args.versionUuid, {
+            path: args.path,
+            parameters: args.parameters,
+            stream: args.stream,
+            tools: args.tools,
+            userMessage: args.userMessage,
+        });
+        // Handle streaming response
+        if (args.stream && result && typeof result === 'object' && Symbol.asyncIterator in result) {
+            const chunks = [];
+            for await (const chunk of result) {
+                chunks.push(chunk);
+            }
+            return { content: chunks.join('') };
+        }
+        return formatOutput(result, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'runPrompt', 'controllers/latitude.controller.ts@runPrompt', args.path, { args }));
+    }
+}
+async function createLog(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'createLog');
+    methodLogger.debug(`Creating log for: ${args.path}`);
+    try {
+        const result = await vendor_latitude_service_js_1.default.createDocumentLog(args.projectId, args.versionUuid, args.path, args.messages);
+        return formatOutput(result, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'createLog', 'controllers/latitude.controller.ts@createLog', args.path, { args }));
+    }
+}
+// ============================================================================
+// Conversations Controller
+// ============================================================================
+async function getConversation(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'getConversation');
+    methodLogger.debug(`Getting conversation: ${args.conversationUuid}`);
+    try {
+        const conversation = await vendor_latitude_service_js_1.default.getConversation(args.conversationUuid);
+        return formatOutput(conversation, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'getConversation', 'controllers/latitude.controller.ts@getConversation', args.conversationUuid, { args }));
+    }
+}
+async function chat(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'chat');
+    methodLogger.debug(`Chatting in conversation: ${args.conversationUuid}`);
+    try {
+        const messages = [{ role: 'user', content: args.message }];
+        const result = await vendor_latitude_service_js_1.default.chatConversation(args.conversationUuid, messages, args.stream);
+        // Handle streaming response
+        if (args.stream && result && typeof result === 'object' && Symbol.asyncIterator in result) {
+            const chunks = [];
+            for await (const chunk of result) {
+                chunks.push(chunk);
+            }
+            return { content: chunks.join('') };
+        }
+        return formatOutput(result, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'chat', 'controllers/latitude.controller.ts@chat', args.conversationUuid, { args }));
+    }
+}
+async function stopConversation(args) {
+    const methodLogger = logger_util_js_1.Logger.forContext('controllers/latitude.controller.ts', 'stopConversation');
+    methodLogger.debug(`Stopping conversation: ${args.conversationUuid}`);
+    try {
+        const result = await vendor_latitude_service_js_1.default.stopConversation(args.conversationUuid);
+        return formatOutput(result, args);
+    }
+    catch (error) {
+        throw (0, error_handler_util_js_1.handleControllerError)(error, (0, error_handler_util_js_1.buildErrorContext)('Latitude', 'stopConversation', 'controllers/latitude.controller.ts@stopConversation', args.conversationUuid, { args }));
+    }
+}
+// ============================================================================
+// Export Controller
+// ============================================================================
+exports.default = {
+    // Projects
+    listProjects,
+    createProject,
+    // Versions
+    listVersions,
+    getVersion,
+    createVersion,
+    publishVersion,
+    pushChanges,
+    // Documents/Prompts
+    listPrompts,
+    getPrompt,
+    pushPrompt,
+    pushPromptFromFile,
+    runPrompt,
+    createLog,
+    // Conversations
+    getConversation,
+    chat,
+    stopConversation,
+};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Start the MCP server with the specified transport mode
+ */
+export declare function startServer(mode?: 'stdio' | 'http'): Promise<McpServer>;

package/dist/index.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const logger_util_js_1 = require("./utils/logger.util.js");
+const config_util_js_1 = require("./utils/config.util.js");
+const constants_util_js_1 = require("./utils/constants.util.js");
+const index_js_1 = require("./cli/index.js");
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+// Import tools and resources
+const latitude_tool_js_1 = __importDefault(require("./tools/latitude.tool.js"));
+const latitude_resource_js_1 = __importDefault(require("./resources/latitude.resource.js"));
+const logger = logger_util_js_1.Logger.forContext('index.ts');
+let serverInstance = null;
+let transportInstance = null;
+/**
+ * Start the MCP server with the specified transport mode
+ */
+async function startServer(mode = 'stdio') {
+    logger.info(`Starting MCP server in ${mode} mode with ${constants_util_js_1.PACKAGE_NAME} v${constants_util_js_1.VERSION}`);
+    const serverLogger = logger_util_js_1.Logger.forContext('index.ts', 'startServer');
+    // Load configuration
+    serverLogger.info('Starting MCP server initialization...');
+    config_util_js_1.config.load();
+    if (config_util_js_1.config.getBoolean('DEBUG')) {
+        serverLogger.debug('Debug mode enabled');
+    }
+    serverLogger.info(`Initializing Latitude MCP server v${constants_util_js_1.VERSION}`);
+    serverInstance = new mcp_js_1.McpServer({
+        name: constants_util_js_1.PACKAGE_NAME,
+        version: constants_util_js_1.VERSION,
+    });
+    // Register tools and resources
+    serverLogger.info('Registering MCP tools and resources...');
+    latitude_tool_js_1.default.registerTools(serverInstance);
+    latitude_resource_js_1.default.registerResources(serverInstance);
+    serverLogger.debug('All Latitude tools and resources registered');
+    if (mode === 'stdio') {
+        serverLogger.info('Using STDIO transport');
+        transportInstance = new stdio_js_1.StdioServerTransport();
+        try {
+            await serverInstance.connect(transportInstance);
+            serverLogger.info('MCP server started successfully on STDIO transport');
+            setupGracefulShutdown();
+            return serverInstance;
+        }
+        catch (err) {
+            serverLogger.error('Failed to start server on STDIO transport', err);
+            process.exit(1);
+        }
+    }
+    else {
+        // HTTP transport with Express
+        serverLogger.info('Using Streamable HTTP transport');
+        const app = (0, express_1.default)();
+        app.use((0, cors_1.default)());
+        app.use(express_1.default.json());
+        const mcpEndpoint = '/mcp';
+        serverLogger.debug(`MCP endpoint: ${mcpEndpoint}`);
+        // Create transport instance
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+            // sessionIdGenerator is optional
+            sessionIdGenerator: undefined,
+        });
+        // Connect server to transport
+        await serverInstance.connect(transport);
+        transportInstance = transport;
+        // Handle all MCP requests
+        app.all(mcpEndpoint, (req, res) => {
+            transport
+                .handleRequest(req, res, req.body)
+                .catch((err) => {
+                serverLogger.error('Error in transport.handleRequest', err);
+                if (!res.headersSent) {
+                    res.status(500).json({
+                        error: 'Internal Server Error',
+                    });
+                }
+            });
+        });
+        // Health check endpoint
+        app.get('/', (_req, res) => {
+            res.send(`Latitude MCP Server v${constants_util_js_1.VERSION} is running`);
+        });
+        // Start HTTP server
+        const PORT = Number(process.env.PORT ?? 3000);
+        await new Promise((resolve) => {
+            app.listen(PORT, () => {
+                serverLogger.info(`HTTP transport listening on http://localhost:${PORT}${mcpEndpoint}`);
+                resolve();
+            });
+        });
+        setupGracefulShutdown();
+        return serverInstance;
+    }
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    const mainLogger = logger_util_js_1.Logger.forContext('index.ts', 'main');
+    // Load configuration
+    config_util_js_1.config.load();
+    // CLI mode - if any arguments are provided
+    if (process.argv.length > 2) {
+        mainLogger.info('CLI mode detected');
+        await (0, index_js_1.runCli)(process.argv.slice(2));
+        return;
+    }
+    // Server mode - determine transport
+    const transportMode = (process.env.TRANSPORT_MODE || 'stdio').toLowerCase();
+    let mode;
+    if (transportMode === 'stdio') {
+        mode = 'stdio';
+    }
+    else if (transportMode === 'http') {
+        mode = 'http';
+    }
+    else {
+        mainLogger.warn(`Unknown TRANSPORT_MODE "${transportMode}", defaulting to stdio`);
+        mode = 'stdio';
+    }
+    mainLogger.info(`Starting server with ${mode.toUpperCase()} transport`);
+    await startServer(mode);
+}
+// Run main if executed directly
+if (require.main === module) {
+    main().catch((err) => {
+        logger.error('Unhandled error in main process', err);
+        process.exit(1);
+    });
+}
+/**
+ * Graceful shutdown handler
+ */
+function setupGracefulShutdown() {
+    const shutdownLogger = logger_util_js_1.Logger.forContext('index.ts', 'shutdown');
+    const shutdown = async () => {
+        try {
+            shutdownLogger.info('Shutting down gracefully...');
+            if (transportInstance &&
+                'close' in transportInstance &&
+                typeof transportInstance.close === 'function') {
+                await transportInstance.close();
+            }
+            if (serverInstance && typeof serverInstance.close === 'function') {
+                await serverInstance.close();
+            }
+            process.exit(0);
+        }
+        catch (err) {
+            shutdownLogger.error('Error during shutdown', err);
+            process.exit(1);
+        }
+    };
+    ['SIGINT', 'SIGTERM'].forEach((signal) => {
+        process.on(signal, shutdown);
+    });
+}

package/dist/resources/latitude.resource.d.ts

@@ -0,0 +1,12 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register Latitude resources with the MCP server
+ * Resources provide read-only access to Latitude data
+ *
+ * @param server The MCP server instance
+ */
+declare function registerResources(server: McpServer): void;
+declare const _default: {
+    registerResources: typeof registerResources;
+};
+export default _default;

package/dist/resources/latitude.resource.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const logger_util_js_1 = require("../utils/logger.util.js");
+const latitude_controller_js_1 = __importDefault(require("../controllers/latitude.controller.js"));
+const error_util_js_1 = require("../utils/error.util.js");
+const logger = logger_util_js_1.Logger.forContext('resources/latitude.resource.ts');
+/**
+ * Register Latitude resources with the MCP server
+ * Resources provide read-only access to Latitude data
+ *
+ * @param server The MCP server instance
+ */
+function registerResources(server) {
+    const registerLogger = logger.forMethod('registerResources');
+    registerLogger.debug('Registering Latitude resources...');
+    // Projects resource - list all projects
+    server.registerResource('latitude-projects', new mcp_js_1.ResourceTemplate('latitude://projects', { list: undefined }), {
+        title: 'Latitude Projects',
+        description: 'List all projects in your Latitude workspace',
+    }, async (uri) => {
+        const methodLogger = logger.forMethod('projectsResource');
+        try {
+            methodLogger.debug('Projects resource called', { uri: uri.href });
+            const result = await latitude_controller_js_1.default.listProjects();
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: result.content,
+                        mimeType: 'application/json',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            methodLogger.error('Resource error', error);
+            return (0, error_util_js_1.formatErrorForMcpResource)(error, uri.href);
+        }
+    });
+    // Versions resource - list versions for a project
+    server.registerResource('latitude-versions', new mcp_js_1.ResourceTemplate('latitude://projects/{projectId}/versions', {
+        list: undefined,
+    }), {
+        title: 'Project Versions',
+        description: 'List all versions (commits) for a Latitude project',
+    }, async (uri, variables) => {
+        const methodLogger = logger.forMethod('versionsResource');
+        try {
+            const projectId = variables.projectId;
+            methodLogger.debug('Versions resource called', {
+                uri: uri.href,
+                projectId,
+            });
+            const result = await latitude_controller_js_1.default.listVersions({ projectId });
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: result.content,
+                        mimeType: 'application/json',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            methodLogger.error('Resource error', error);
+            return (0, error_util_js_1.formatErrorForMcpResource)(error, uri.href);
+        }
+    });
+    // Prompts resource - list prompts for a version
+    server.registerResource('latitude-prompts', new mcp_js_1.ResourceTemplate('latitude://projects/{projectId}/versions/{versionUuid}/prompts', { list: undefined }), {
+        title: 'Version Prompts',
+        description: 'List all prompts/documents in a Latitude project version',
+    }, async (uri, variables) => {
+        const methodLogger = logger.forMethod('promptsResource');
+        try {
+            const projectId = variables.projectId;
+            const versionUuid = variables.versionUuid || 'live';
+            methodLogger.debug('Prompts resource called', {
+                uri: uri.href,
+                projectId,
+                versionUuid,
+            });
+            const result = await latitude_controller_js_1.default.listPrompts({
+                projectId,
+                versionUuid,
+            });
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: result.content,
+                        mimeType: 'application/json',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            methodLogger.error('Resource error', error);
+            return (0, error_util_js_1.formatErrorForMcpResource)(error, uri.href);
+        }
+    });
+    // Single prompt resource - get a specific prompt
+    server.registerResource('latitude-prompt', new mcp_js_1.ResourceTemplate('latitude://projects/{projectId}/versions/{versionUuid}/prompts/{path}', { list: undefined }), {
+        title: 'Prompt Content',
+        description: 'Get a specific prompt by path from a Latitude project',
+    }, async (uri, variables) => {
+        const methodLogger = logger.forMethod('promptResource');
+        try {
+            const projectId = variables.projectId;
+            const versionUuid = variables.versionUuid || 'live';
+            const path = variables.path;
+            methodLogger.debug('Prompt resource called', {
+                uri: uri.href,
+                projectId,
+                versionUuid,
+                path,
+            });
+            const result = await latitude_controller_js_1.default.getPrompt({
+                projectId,
+                versionUuid,
+                path,
+            });
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        text: result.content,
+                        mimeType: 'application/json',
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            methodLogger.error('Resource error', error);
+            return (0, error_util_js_1.formatErrorForMcpResource)(error, uri.href);
+        }
+    });
+    registerLogger.debug('Latitude resources registered successfully');
+}
+exports.default = { registerResources };

package/dist/services/vendor.latitude.service.d.ts

@@ -0,0 +1,49 @@
+import { Project, Version, Document, Conversation, PushChanges } from '../types/latitude.types.js';
+declare function listProjects(): Promise<Project[]>;
+declare function createProject(name: string): Promise<Project>;
+declare function listVersions(projectId: string): Promise<Version[]>;
+declare function getVersion(projectId: string, versionUuid: string): Promise<Version>;
+declare function createVersion(projectId: string, name: string): Promise<Version>;
+declare function publishVersion(projectId: string, versionUuid: string, options?: {
+    title?: string;
+    description?: string;
+}): Promise<Version>;
+declare function pushChanges(projectId: string, versionUuid: string, changes: PushChanges): Promise<unknown>;
+declare function listDocuments(projectId: string, versionUuid: string): Promise<Document[]>;
+declare function getDocument(projectId: string, versionUuid: string, path: string): Promise<Document>;
+declare function createOrUpdateDocument(projectId: string, versionUuid: string, path: string, prompt: string, force?: boolean): Promise<Document>;
+declare function runDocument(projectId: string, versionUuid: string, options: {
+    path: string;
+    parameters?: Record<string, unknown>;
+    stream?: boolean;
+    tools?: string[];
+    userMessage?: string;
+}): Promise<unknown>;
+declare function createDocumentLog(projectId: string, versionUuid: string, path: string, messages: Array<{
+    role: string;
+    content: string;
+}>): Promise<unknown>;
+declare function getConversation(conversationUuid: string): Promise<Conversation>;
+declare function chatConversation(conversationUuid: string, messages: Array<{
+    role: string;
+    content: string;
+}>, stream?: boolean): Promise<unknown>;
+declare function stopConversation(conversationUuid: string): Promise<unknown>;
+declare const _default: {
+    listProjects: typeof listProjects;
+    createProject: typeof createProject;
+    listVersions: typeof listVersions;
+    getVersion: typeof getVersion;
+    createVersion: typeof createVersion;
+    publishVersion: typeof publishVersion;
+    pushChanges: typeof pushChanges;
+    listDocuments: typeof listDocuments;
+    getDocument: typeof getDocument;
+    createOrUpdateDocument: typeof createOrUpdateDocument;
+    runDocument: typeof runDocument;
+    createDocumentLog: typeof createDocumentLog;
+    getConversation: typeof getConversation;
+    chatConversation: typeof chatConversation;
+    stopConversation: typeof stopConversation;
+};
+export default _default;