latitude-mcp-server 1.0.0

package/dist/cli/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Run the CLI with the provided arguments
+ *
+ * @param args Command line arguments to process
+ * @returns Promise that resolves when CLI command execution completes
+ */
+export declare function runCli(args: string[]): Promise<void>;

package/dist/cli/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const logger_util_js_1 = require("../utils/logger.util.js");
+const constants_util_js_1 = require("../utils/constants.util.js");
+const latitude_cli_js_1 = __importDefault(require("./latitude.cli.js"));
+/**
+ * CLI entry point for the Latitude MCP Server
+ * Handles command registration, parsing, and execution
+ */
+// Package description
+const DESCRIPTION = 'MCP server for Latitude prompt management - manage prompts, versions, and run AI conversations';
+/**
+ * Run the CLI with the provided arguments
+ *
+ * @param args Command line arguments to process
+ * @returns Promise that resolves when CLI command execution completes
+ */
+async function runCli(args) {
+    const cliLogger = logger_util_js_1.Logger.forContext('cli/index.ts', 'runCli');
+    cliLogger.debug('Initializing CLI with arguments', args);
+    const program = new commander_1.Command();
+    program.name(constants_util_js_1.CLI_NAME).description(DESCRIPTION).version(constants_util_js_1.VERSION);
+    // Register CLI commands
+    cliLogger.debug('Registering CLI commands...');
+    latitude_cli_js_1.default.register(program);
+    cliLogger.debug('CLI commands registered successfully');
+    // Handle unknown commands
+    program.on('command:*', (operands) => {
+        cliLogger.error(`Unknown command: ${operands[0]}`);
+        console.log('');
+        program.help();
+        process.exit(1);
+    });
+    // Parse arguments; default to help if no command provided
+    cliLogger.debug('Parsing CLI arguments');
+    await program.parseAsync(args.length ? args : ['--help'], { from: 'user' });
+    cliLogger.debug('CLI command execution completed');
+}

package/dist/cli/latitude.cli.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+/**
+ * Register Latitude CLI commands
+ * @param program The Commander program instance
+ */
+declare function register(program: Command): void;
+declare const _default: {
+    register: typeof register;
+};
+export default _default;

package/dist/cli/latitude.cli.js

@@ -0,0 +1,286 @@
+"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 error_util_js_1 = require("../utils/error.util.js");
+const latitude_controller_js_1 = __importDefault(require("../controllers/latitude.controller.js"));
+/**
+ * Read content from file path or stdin
+ */
+function readContentFromFile(filePath) {
+    const absolutePath = (0, path_1.resolve)(filePath);
+    if (!(0, fs_1.existsSync)(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+    }
+    return (0, fs_1.readFileSync)(absolutePath, 'utf-8');
+}
+/**
+ * Derive prompt path from filename if not provided
+ * 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;
+}
+const logger = logger_util_js_1.Logger.forContext('cli/latitude.cli.ts');
+/**
+ * Register Latitude CLI commands
+ * @param program The Commander program instance
+ */
+function register(program) {
+    const methodLogger = logger.forMethod('register');
+    methodLogger.debug('Registering Latitude CLI commands...');
+    // Projects command group
+    const projects = program
+        .command('projects')
+        .description('Manage Latitude projects');
+    projects
+        .command('list')
+        .description('List all projects in your workspace')
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (options) => {
+        try {
+            const result = await latitude_controller_js_1.default.listProjects({
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    projects
+        .command('create <name>')
+        .description('Create a new project')
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (name, options) => {
+        try {
+            const result = await latitude_controller_js_1.default.createProject({
+                name,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    // Versions command group
+    const versions = program
+        .command('versions')
+        .description('Manage project versions');
+    versions
+        .command('list <projectId>')
+        .description('List all versions for a project')
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (projectId, options) => {
+        try {
+            const result = await latitude_controller_js_1.default.listVersions({
+                projectId,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    versions
+        .command('create <projectId> <name>')
+        .description('Create a new draft version')
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (projectId, name, options) => {
+        try {
+            const result = await latitude_controller_js_1.default.createVersion({
+                projectId,
+                name,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    versions
+        .command('publish <projectId> <versionUuid>')
+        .description('Publish a draft version to make it live')
+        .option('-t, --title <title>', 'Publication title')
+        .option('-d, --description <description>', 'Publication description')
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (projectId, versionUuid, options) => {
+        try {
+            const result = await latitude_controller_js_1.default.publishVersion({
+                projectId,
+                versionUuid,
+                title: options.title,
+                description: options.description,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    // Prompts command group
+    const prompts = program
+        .command('prompts')
+        .description('Manage prompts/documents');
+    prompts
+        .command('list <projectId>')
+        .description('List all prompts in a version')
+        .option('-v, --version-uuid <versionUuid>', 'Version UUID (default: "live")', 'live')
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (projectId, options) => {
+        try {
+            const result = await latitude_controller_js_1.default.listPrompts({
+                projectId,
+                versionUuid: options.versionUuid,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    prompts
+        .command('get <projectId> <path>')
+        .description('Get a specific prompt by path')
+        .option('-v, --version-uuid <versionUuid>', 'Version UUID (default: "live")', 'live')
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (projectId, path, options) => {
+        try {
+            const result = await latitude_controller_js_1.default.getPrompt({
+                projectId,
+                versionUuid: options.versionUuid,
+                path,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    // Push command (standalone like git push)
+    // Supports: --file path/to/prompt.md OR --content "inline content"
+    program
+        .command('push <projectId> <versionUuid> [promptPath]')
+        .description('Push a prompt to a draft version. Use --file to read from a file, or --content for inline.')
+        .option('-i, --file <filePath>', 'Read prompt content from file (supports .md, .promptl)')
+        .option('-c, --content <content>', 'Prompt content in PromptL format (inline)')
+        .option('-f, --force', 'Force overwrite if exists', false)
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (projectId, versionUuid, promptPath, options) => {
+        try {
+            let content;
+            let finalPath;
+            // Determine content source
+            if (options.file) {
+                // Read from file
+                const filePath = options.file;
+                content = readContentFromFile(filePath);
+                // Use provided promptPath or derive from filename
+                finalPath = promptPath || derivePromptPath(filePath);
+                console.log(`Reading from: ${(0, path_1.resolve)(filePath)}`);
+            }
+            else if (options.content) {
+                // Use inline content
+                content = options.content;
+                if (!promptPath) {
+                    console.error('Error: promptPath is required when using --content');
+                    process.exit(1);
+                }
+                finalPath = promptPath;
+            }
+            else {
+                console.error('Error: Either --file or --content is required');
+                console.error('  Example with file:    latitude-mcp push proj123 draft456 --file ./my-prompt.md');
+                console.error('  Example with content: latitude-mcp push proj123 draft456 my-prompt --content "..."');
+                process.exit(1);
+            }
+            const result = await latitude_controller_js_1.default.pushPrompt({
+                projectId,
+                versionUuid,
+                path: finalPath,
+                content,
+                force: options.force,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    // Run command (execute a prompt)
+    program
+        .command('run <projectId> <path>')
+        .description('Execute a prompt and get AI response')
+        .option('-v, --version-uuid <versionUuid>', 'Version UUID (default: "live")', 'live')
+        .option('-p, --parameters <json>', 'Parameters as JSON object')
+        .option('-m, --message <message>', 'Additional user message')
+        .option('-s, --stream', 'Enable streaming response', false)
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (projectId, path, options) => {
+        try {
+            let parameters;
+            if (options.parameters) {
+                try {
+                    parameters = JSON.parse(options.parameters);
+                }
+                catch {
+                    console.error('Error: Invalid JSON in --parameters');
+                    process.exit(1);
+                }
+            }
+            const result = await latitude_controller_js_1.default.runPrompt({
+                projectId,
+                versionUuid: options.versionUuid,
+                path,
+                parameters,
+                userMessage: options.message,
+                stream: options.stream,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    // Chat command (continue conversation)
+    program
+        .command('chat <conversationUuid>')
+        .description('Continue a conversation')
+        .requiredOption('-m, --message <message>', 'User message to send')
+        .option('-s, --stream', 'Enable streaming response', false)
+        .option('-o, --output-format <format>', 'Output format: "toon" or "json"', 'toon')
+        .action(async (conversationUuid, options) => {
+        try {
+            const result = await latitude_controller_js_1.default.chat({
+                conversationUuid,
+                message: options.message,
+                stream: options.stream,
+                outputFormat: options.outputFormat,
+            });
+            console.log(result.content);
+        }
+        catch (error) {
+            (0, error_util_js_1.handleCliError)(error);
+        }
+    });
+    methodLogger.debug('Latitude CLI commands registered successfully');
+}
+exports.default = { register };

package/dist/controllers/latitude.controller.d.ts

@@ -0,0 +1,115 @@
+import { DocumentChange } from '../types/latitude.types.js';
+/**
+ * Output format type
+ */
+type OutputFormat = 'toon' | 'json';
+/**
+ * Controller response type
+ */
+interface ControllerResponse {
+    content: string;
+}
+/**
+ * Common controller options
+ */
+interface ControllerOptions {
+    jq?: string;
+    outputFormat?: OutputFormat;
+}
+declare function listProjects(options?: ControllerOptions): Promise<ControllerResponse>;
+declare function createProject(args: {
+    name: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function listVersions(args: {
+    projectId: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function getVersion(args: {
+    projectId: string;
+    versionUuid: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function createVersion(args: {
+    projectId: string;
+    name: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function publishVersion(args: {
+    projectId: string;
+    versionUuid: string;
+    title?: string;
+    description?: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function pushChanges(args: {
+    projectId: string;
+    versionUuid: string;
+    changes: DocumentChange[];
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function listPrompts(args: {
+    projectId: string;
+    versionUuid: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function getPrompt(args: {
+    projectId: string;
+    versionUuid: string;
+    path: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function pushPrompt(args: {
+    projectId: string;
+    versionUuid: string;
+    path: string;
+    content: string;
+    force?: boolean;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function pushPromptFromFile(args: {
+    projectId: string;
+    versionUuid: string;
+    filePath: string;
+    promptPath?: string;
+    force?: boolean;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function runPrompt(args: {
+    projectId: string;
+    versionUuid: string;
+    path: string;
+    parameters?: Record<string, unknown>;
+    stream?: boolean;
+    tools?: string[];
+    userMessage?: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function createLog(args: {
+    projectId: string;
+    versionUuid: string;
+    path: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function getConversation(args: {
+    conversationUuid: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function chat(args: {
+    conversationUuid: string;
+    message: string;
+    stream?: boolean;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare function stopConversation(args: {
+    conversationUuid: string;
+} & ControllerOptions): Promise<ControllerResponse>;
+declare const _default: {
+    listProjects: typeof listProjects;
+    createProject: typeof createProject;
+    listVersions: typeof listVersions;
+    getVersion: typeof getVersion;
+    createVersion: typeof createVersion;
+    publishVersion: typeof publishVersion;
+    pushChanges: typeof pushChanges;
+    listPrompts: typeof listPrompts;
+    getPrompt: typeof getPrompt;
+    pushPrompt: typeof pushPrompt;
+    pushPromptFromFile: typeof pushPromptFromFile;
+    runPrompt: typeof runPrompt;
+    createLog: typeof createLog;
+    getConversation: typeof getConversation;
+    chat: typeof chat;
+    stopConversation: typeof stopConversation;
+};
+export default _default;