latitude-mcp-server 3.2.2 → 3.3.0

package/dist/api.d.ts

@@ -33,6 +33,10 @@ export declare class LatitudeApiError extends Error {
  */
 export declare function getProjectId(): string;
 export declare function listDocuments(versionUuid?: string): Promise<Document[]>;
+/**
+ * Compute SHA-256 hash of content (matches Latitude's contentHash)
+ */
+export declare function computeContentHash(content: string): string;
 export declare function getDocument(path: string, versionUuid?: string): Promise<Document>;
 /**
  * Push response from the API
@@ -42,13 +46,26 @@ interface PushResponse {
     documentsProcessed: number;
 }
 /**
- * Push changes to a version in a single batch
- * This is the CLI-style push that sends all changes at once
+ * Push changes to a version
+ *
+ * IMPORTANT: The Latitude API /push endpoint has a bug where 'modified' status
+ * fails with "A document with the same path already exists" error for inherited
+ * documents in drafts. Workaround: for modified docs, we first delete then add
+ * in sequential push calls.
  */
 export declare function pushChanges(versionUuid: string, changes: DocumentChange[]): Promise<PushResponse>;
+/**
+ * Normalize document path for consistent comparison.
+ * Handles leading/trailing slashes, whitespace, and ensures consistent format.
+ * API may return paths with or without leading slash - this normalizes them.
+ */
+export declare function normalizePath(path: string): string;
 /**
  * Compute diff between incoming prompts and existing prompts
  * Returns only the changes that need to be made
+ *
+ * IMPORTANT: Uses normalized paths and content hashes for fast comparison.
+ * Handles API inconsistencies where paths may have leading slashes.
  */
 export declare function computeDiff(incoming: Array<{
     path: string;

package/dist/api.js

@@ -16,12 +16,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LatitudeApiError = void 0;
 exports.getProjectId = getProjectId;
 exports.listDocuments = listDocuments;
+exports.computeContentHash = computeContentHash;
 exports.getDocument = getDocument;
 exports.pushChanges = pushChanges;
+exports.normalizePath = normalizePath;
 exports.computeDiff = computeDiff;
 exports.runDocument = runDocument;
 exports.validatePromptLContent = validatePromptLContent;
 exports.deployToLive = deployToLive;
+const crypto_1 = require("crypto");
 const logger_util_js_1 = require("./utils/logger.util.js");
 const config_util_js_1 = require("./utils/config.util.js");
 const promptl_ai_1 = require("promptl-ai");
@@ -278,40 +281,97 @@ async function listDocuments(versionUuid = 'live') {
     const projectId = getProjectId();
     return request(`/projects/${projectId}/versions/${versionUuid}/documents`);
 }
+/**
+ * Compute SHA-256 hash of content (matches Latitude's contentHash)
+ */
+function computeContentHash(content) {
+    return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+}
 async function getDocument(path, versionUuid = 'live') {
     const projectId = getProjectId();
     const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
     return request(`/projects/${projectId}/versions/${versionUuid}/documents/${normalizedPath}`);
 }
 /**
- * Push changes to a version in a single batch
- * This is the CLI-style push that sends all changes at once
+ * Push changes to a version
+ *
+ * IMPORTANT: The Latitude API /push endpoint has a bug where 'modified' status
+ * fails with "A document with the same path already exists" error for inherited
+ * documents in drafts. Workaround: for modified docs, we first delete then add
+ * in sequential push calls.
  */
 async function pushChanges(versionUuid, changes) {
     const projectId = getProjectId();
-    // Format changes for the API
-    const apiChanges = changes.map((c) => ({
+    // Separate changes by type
+    const modified = changes.filter((c) => c.status === 'modified');
+    const nonModified = changes.filter((c) => c.status !== 'modified');
+    let totalProcessed = 0;
+    // Step 1: If there are modified docs, delete them first
+    if (modified.length > 0) {
+        const deleteChanges = modified.map((c) => ({
+            path: c.path,
+            content: '',
+            status: 'deleted',
+        }));
+        logger.info(`Deleting ${modified.length} modified doc(s) before re-adding...`);
+        await request(`/projects/${projectId}/versions/${versionUuid}/push`, {
+            method: 'POST',
+            body: { changes: deleteChanges },
+        });
+    }
+    // Step 2: Push all adds (including modified-as-add) and deletes
+    const addChanges = modified.map((c) => ({
+        path: c.path,
+        content: c.content || '',
+        status: 'added',
+    }));
+    const otherChanges = nonModified.map((c) => ({
         path: c.path,
         content: c.content || '',
         status: c.status,
     }));
-    logger.info(`Pushing ${changes.length} change(s) to version ${versionUuid}`);
-    return request(`/projects/${projectId}/versions/${versionUuid}/push`, {
-        method: 'POST',
-        body: { changes: apiChanges },
-    });
+    const allChanges = [...addChanges, ...otherChanges];
+    if (allChanges.length > 0) {
+        logger.info(`Pushing ${allChanges.length} change(s) to version ${versionUuid}`);
+        const result = await request(`/projects/${projectId}/versions/${versionUuid}/push`, {
+            method: 'POST',
+            body: { changes: allChanges },
+        });
+        totalProcessed = result.documentsProcessed;
+    }
+    return {
+        versionUuid,
+        documentsProcessed: totalProcessed || changes.length,
+    };
+}
+/**
+ * Normalize document path for consistent comparison.
+ * Handles leading/trailing slashes, whitespace, and ensures consistent format.
+ * API may return paths with or without leading slash - this normalizes them.
+ */
+function normalizePath(path) {
+    return path
+        .trim()
+        .replace(/^\/+/, '') // Remove leading slashes
+        .replace(/\/+$/, '') // Remove trailing slashes
+        .replace(/\/+/g, '/'); // Collapse multiple slashes
 }
 /**
  * Compute diff between incoming prompts and existing prompts
  * Returns only the changes that need to be made
+ *
+ * IMPORTANT: Uses normalized paths and content hashes for fast comparison.
+ * Handles API inconsistencies where paths may have leading slashes.
  */
 function computeDiff(incoming, existing) {
     const changes = [];
-    const existingMap = new Map(existing.map((d) => [d.path, d]));
-    const incomingPaths = new Set(incoming.map((p) => p.path));
+    // Build map with NORMALIZED paths as keys, storing path + contentHash for fast comparison
+    const existingMap = new Map(existing.map((d) => [normalizePath(d.path), { path: d.path, contentHash: d.contentHash }]));
+    const incomingPaths = new Set(incoming.map((p) => normalizePath(p.path)));
     // Check each incoming prompt
     for (const prompt of incoming) {
-        const existingDoc = existingMap.get(prompt.path);
+        const normalizedPath = normalizePath(prompt.path);
+        const existingDoc = existingMap.get(normalizedPath);
         if (!existingDoc) {
             // New prompt
             changes.push({
@@ -320,21 +380,25 @@ function computeDiff(incoming, existing) {
                 status: 'added',
             });
         }
-        else if (existingDoc.content !== prompt.content) {
-            // Modified prompt
-            changes.push({
-                path: prompt.path,
-                content: prompt.content,
-                status: 'modified',
-            });
+        else {
+            // Compare hashes for speed (avoid comparing large content strings)
+            const localHash = computeContentHash(prompt.content);
+            if (existingDoc.contentHash !== localHash) {
+                // Modified prompt - use the EXISTING path to ensure API compatibility
+                changes.push({
+                    path: existingDoc.path,
+                    content: prompt.content,
+                    status: 'modified',
+                });
+            }
         }
-        // If content is same, no change needed (don't include in changes)
+        // If same hash, no change needed (don't include in changes)
     }
     // Check for deleted prompts (exist remotely but not in incoming)
-    for (const path of existingMap.keys()) {
-        if (!incomingPaths.has(path)) {
+    for (const [normalizedExistingPath, doc] of existingMap.entries()) {
+        if (!incomingPaths.has(normalizedExistingPath)) {
             changes.push({
-                path,
+                path: doc.path,
                 content: '',
                 status: 'deleted',
             });

package/dist/tools.js

@@ -28,6 +28,8 @@ async function refreshPromptCache() {
     try {
         const docs = await (0, api_js_1.listDocuments)('live');
         cachedPromptNames = docs.map((d) => d.path);
+        // Also cache full documents for variable extraction (avoids extra API calls)
+        cachedDocuments = docs.map((d) => ({ path: d.path, content: d.content }));
         cacheLastUpdated = new Date();
         logger.debug(`Cache updated: ${cachedPromptNames.length} prompts`);
         return cachedPromptNames;
@@ -128,10 +130,14 @@ function extractVariables(content) {
     }
     return Array.from(variables);
 }
+// Cache for full documents (path + content) to avoid repeated API calls
+let cachedDocuments = [];
 /**
  * Build dynamic description for run_prompt with prompt names and their variables
+ * Uses cached documents to avoid individual API calls per prompt
  */
 async function buildRunPromptDescription() {
+    // Use cached documents if available, otherwise just show names
     const names = await getCachedPromptNames();
     let desc = 'Execute a prompt with parameters.';
     if (names.length === 0) {
@@ -139,12 +145,13 @@ async function buildRunPromptDescription() {
         return desc;
     }
     desc += `\n\n**Available prompts (${names.length}):**`;
-    // Fetch each prompt to get its variables (limit to avoid too long description)
+    // Use cached documents for variable extraction (no extra API calls)
     const maxToShow = Math.min(names.length, 10);
+    const docMap = new Map(cachedDocuments.map(d => [d.path, d.content]));
     for (let i = 0; i < maxToShow; i++) {
-        try {
-            const doc = await (0, api_js_1.getDocument)(names[i], 'live');
-            const vars = extractVariables(doc.content);
+        const content = docMap.get(names[i]);
+        if (content) {
+            const vars = extractVariables(content);
             if (vars.length > 0) {
                 desc += `\n- \`${names[i]}\` (params: ${vars.map(v => `\`${v}\``).join(', ')})`;
             }
@@ -152,7 +159,7 @@ async function buildRunPromptDescription() {
                 desc += `\n- \`${names[i]}\` (no params)`;
             }
         }
-        catch {
+        else {
             desc += `\n- \`${names[i]}\``;
         }
     }
@@ -332,9 +339,10 @@ async function handlePushPrompts(args) {
         const modified = changes.filter((c) => c.status === 'modified');
         const deleted = changes.filter((c) => c.status === 'deleted');
         if (changes.length === 0) {
-            const newNames = await forceRefreshAndGetNames();
+            // No changes - reuse existingDocs instead of another API call
+            const currentNames = existingDocs.map(d => d.path);
             return formatSuccess('No Changes Needed', `All ${prompts.length} prompt(s) are already up to date.\n\n` +
-                `**Current LIVE prompts (${newNames.length}):** ${newNames.map(n => `\`${n}\``).join(', ')}`);
+                `**Current LIVE prompts (${currentNames.length}):** ${currentNames.map(n => `\`${n}\``).join(', ')}`);
         }
         // Push all changes in one batch
         try {
@@ -415,23 +423,29 @@ async function handleAddPrompt(args) {
             return formatValidationErrors(validation.errors);
         }
         logger.info(`All ${prompts.length} prompt(s) passed validation`);
-        // Get existing prompts
+        // Get existing prompts (includes contentHash for fast comparison)
         const existingDocs = await (0, api_js_1.listDocuments)('live');
-        const existingMap = new Map(existingDocs.map((d) => [d.path, d]));
+        // Use NORMALIZED paths as keys for reliable matching (handles /path vs path inconsistencies)
+        // Map to { path, contentHash } for fast hash-based comparison
+        const existingMap = new Map(existingDocs.map((d) => [(0, api_js_1.normalizePath)(d.path), { path: d.path, contentHash: d.contentHash }]));
         // Build changes - ALWAYS overwrite if exists, add if new, NEVER delete
+        // Uses hash comparison for speed (avoids comparing 100KB+ content strings)
         const changes = [];
         for (const prompt of prompts) {
-            const existingDoc = existingMap.get(prompt.name);
+            const normalizedName = (0, api_js_1.normalizePath)(prompt.name);
+            const existingDoc = existingMap.get(normalizedName);
             if (existingDoc) {
-                // Only include if content is different
-                if (existingDoc.content !== prompt.content) {
+                // Compare hashes instead of full content (much faster)
+                const localHash = (0, api_js_1.computeContentHash)(prompt.content);
+                if (existingDoc.contentHash !== localHash) {
+                    // Use the EXISTING path from API to ensure compatibility
                     changes.push({
-                        path: prompt.name,
+                        path: existingDoc.path,
                         content: prompt.content,
                         status: 'modified',
                     });
                 }
-                // If same content, skip silently (unchanged)
+                // If same hash, skip silently (unchanged)
             }
             else {
                 // New prompt
@@ -446,9 +460,10 @@ async function handleAddPrompt(args) {
         const added = changes.filter((c) => c.status === 'added');
         const modified = changes.filter((c) => c.status === 'modified');
         if (changes.length === 0) {
-            const newNames = await forceRefreshAndGetNames();
+            // No changes - reuse existingDocs instead of another API call
+            const currentNames = existingDocs.map(d => d.path);
             return formatSuccess('No Changes Needed', `All ${prompts.length} prompt(s) are already up to date.\n\n` +
-                `**Current LIVE prompts (${newNames.length}):** ${newNames.map(n => `\`${n}\``).join(', ')}`);
+                `**Current LIVE prompts (${currentNames.length}):** ${currentNames.map(n => `\`${n}\``).join(', ')}`);
         }
         // Push all changes in one batch
         try {
@@ -501,18 +516,17 @@ async function handlePullPrompts(args) {
         for (const file of existingFiles) {
             (0, fs_1.unlinkSync)((0, path_1.join)(outputDir, file));
         }
-        // Get all prompts from LIVE
+        // Get all prompts from LIVE (includes full content)
         const docs = await (0, api_js_1.listDocuments)('live');
         if (docs.length === 0) {
             return formatSuccess('No Prompts to Pull', 'The project has no prompts.');
         }
-        // Fetch full content and write files
+        // Write files directly - listDocuments already returns full content
         const written = [];
         for (const doc of docs) {
-            const fullDoc = await (0, api_js_1.getDocument)(doc.path, 'live');
             const filename = `${doc.path.replace(/\//g, '_')}.promptl`;
             const filepath = (0, path_1.join)(outputDir, filename);
-            (0, fs_1.writeFileSync)(filepath, fullDoc.content, 'utf-8');
+            (0, fs_1.writeFileSync)(filepath, doc.content, 'utf-8');
             written.push(filename);
         }
         // Update cache

package/dist/types.d.ts

@@ -27,6 +27,7 @@ export interface Document {
     uuid: string;
     path: string;
     content: string;
+    contentHash?: string;
     config?: Record<string, unknown>;
     parameters?: Record<string, unknown>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "latitude-mcp-server",
-	"version": "3.2.2",
+	"version": "3.3.0",
 	"description": "Simplified MCP server for Latitude.so prompt management - 8 focused tools for push, pull, run, and manage prompts",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/.releaserc.json

@@ -1,34 +0,0 @@
-{
-	"branches": ["main"],
-	"plugins": [
-		"@semantic-release/commit-analyzer",
-		"@semantic-release/release-notes-generator",
-		"@semantic-release/changelog",
-		[
-			"@semantic-release/exec",
-			{
-				"prepareCmd": "node scripts/update-version.js ${nextRelease.version} && npm run build && chmod +x dist/index.js"
-			}
-		],
-		[
-			"@semantic-release/npm",
-			{
-				"npmPublish": true,
-				"pkgRoot": "."
-			}
-		],
-		[
-			"@semantic-release/git",
-			{
-				"assets": [
-					"package.json",
-					"CHANGELOG.md",
-					"src/index.ts",
-					"src/cli/index.ts"
-				],
-				"message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
-			}
-		],
-		"@semantic-release/github"
-	]
-}