latitude-mcp-server 2.1.7 → 2.2.1

package/dist/api.d.ts

@@ -16,8 +16,17 @@ export declare class LatitudeApiError extends Error {
     readonly errorCode: string;
     readonly statusCode: number;
     readonly details?: Record<string, unknown>;
-    constructor(error: LatitudeError, statusCode: number);
+    readonly rawResponse?: string;
+    constructor(error: LatitudeError, statusCode: number, rawResponse?: string);
+    /**
+     * Extract detailed error messages from nested error structures
+     */
+    getDetailedErrors(): string[];
     toMarkdown(): string;
+    /**
+     * Get a concise error message suitable for per-prompt error tracking
+     */
+    getConciseMessage(): string;
 }
 /**
  * Get project ID from config
@@ -30,10 +39,39 @@ export declare function listDocuments(versionUuid?: string): Promise<Document[]>
 export declare function getDocument(path: string, versionUuid?: string): Promise<Document>;
 export declare function createOrUpdateDocument(versionUuid: string, path: string, content: string, force?: boolean): Promise<Document>;
 export declare function deleteDocument(versionUuid: string, path: string): Promise<void>;
+/**
+ * Push response from the API
+ */
+interface PushResponse {
+    versionUuid: string;
+    documentsProcessed: number;
+}
+/**
+ * Push changes to a version in a single batch
+ * This is the CLI-style push that sends all changes at once
+ */
+export declare function pushChanges(versionUuid: string, changes: DocumentChange[]): Promise<PushResponse>;
+/**
+ * Compute hash of content for diff comparison
+ */
+export declare function hashContent(content: string): string;
+/**
+ * Compute diff between incoming prompts and existing prompts
+ * Returns only the changes that need to be made
+ */
+export declare function computeDiff(incoming: Array<{
+    path: string;
+    content: string;
+}>, existing: Document[]): DocumentChange[];
 export declare function runDocument(path: string, parameters?: Record<string, unknown>, versionUuid?: string): Promise<RunResult>;
 /**
- * Deploy changes directly to LIVE version using force mode
- * This bypasses the draft->publish workflow which requires provider validation
+ * Deploy changes to LIVE version using the proper workflow:
+ * 1. Create a draft version
+ * 2. Push all changes to the draft (batch)
+ * 3. Publish the draft to make it LIVE
+ *
+ * This is the same workflow the CLI uses, ensuring proper validation.
  */
-export declare function deployToLive(changes: DocumentChange[], _versionName?: string): Promise<DeployResult>;
+export declare function deployToLive(changes: DocumentChange[], versionName?: string): Promise<DeployResult>;
 export declare function getPromptNames(): Promise<string[]>;
+export {};

package/dist/api.js

@@ -22,6 +22,9 @@ exports.listDocuments = listDocuments;
 exports.getDocument = getDocument;
 exports.createOrUpdateDocument = createOrUpdateDocument;
 exports.deleteDocument = deleteDocument;
+exports.pushChanges = pushChanges;
+exports.hashContent = hashContent;
+exports.computeDiff = computeDiff;
 exports.runDocument = runDocument;
 exports.deployToLive = deployToLive;
 exports.getPromptNames = getPromptNames;
@@ -72,7 +75,17 @@ async function request(endpoint, options = {}) {
             const errorText = await response.text();
             let errorData;
             try {
-                errorData = JSON.parse(errorText);
+                const parsed = JSON.parse(errorText);
+                // Capture the ENTIRE parsed response as details
+                // This ensures we never lose any error information from the API
+                const { name, errorCode, code, message, ...rest } = parsed;
+                errorData = {
+                    name: name || 'APIError',
+                    errorCode: errorCode || code || `HTTP_${response.status}`,
+                    message: message || `HTTP ${response.status}`,
+                    // Store ALL remaining fields as details
+                    details: Object.keys(rest).length > 0 ? rest : undefined,
+                };
             }
             catch {
                 errorData = {
@@ -81,7 +94,8 @@ async function request(endpoint, options = {}) {
                     message: errorText || `HTTP ${response.status}`,
                 };
             }
-            throw new LatitudeApiError(errorData, response.status);
+            logger.debug(`API error response: ${errorText}`);
+            throw new LatitudeApiError(errorData, response.status, errorText);
         }
         // Handle empty responses
         const contentLength = response.headers.get('content-length');
@@ -113,12 +127,81 @@ async function request(endpoint, options = {}) {
 // Error Class
 // ============================================================================
 class LatitudeApiError extends Error {
-    constructor(error, statusCode) {
+    constructor(error, statusCode, rawResponse) {
         super(error.message);
         this.name = error.name;
         this.errorCode = error.errorCode;
         this.statusCode = statusCode;
         this.details = error.details;
+        this.rawResponse = rawResponse;
+    }
+    /**
+     * Extract detailed error messages from nested error structures
+     */
+    getDetailedErrors() {
+        const errors = [];
+        if (!this.details)
+            return errors;
+        // Handle errors array in details
+        if (Array.isArray(this.details.errors)) {
+            for (const err of this.details.errors) {
+                if (typeof err === 'string') {
+                    errors.push(err);
+                }
+                else if (err && typeof err === 'object') {
+                    const errObj = err;
+                    const msg = errObj.message || errObj.error || errObj.detail || JSON.stringify(err);
+                    const path = errObj.path || errObj.document || errObj.name || '';
+                    errors.push(path ? `${path}: ${msg}` : String(msg));
+                }
+            }
+        }
+        // Handle documents with errors
+        if (this.details.documents && typeof this.details.documents === 'object') {
+            const docs = this.details.documents;
+            for (const [docPath, docInfo] of Object.entries(docs)) {
+                if (docInfo && typeof docInfo === 'object') {
+                    const info = docInfo;
+                    if (info.error || info.errors) {
+                        const docErrors = info.errors || [info.error];
+                        for (const e of Array.isArray(docErrors) ? docErrors : [docErrors]) {
+                            errors.push(`${docPath}: ${typeof e === 'string' ? e : JSON.stringify(e)}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Handle validation errors object
+        if (this.details.validationErrors && typeof this.details.validationErrors === 'object') {
+            const valErrors = this.details.validationErrors;
+            for (const [field, fieldErrors] of Object.entries(valErrors)) {
+                if (Array.isArray(fieldErrors)) {
+                    for (const fe of fieldErrors) {
+                        errors.push(`${field}: ${typeof fe === 'string' ? fe : JSON.stringify(fe)}`);
+                    }
+                }
+                else {
+                    errors.push(`${field}: ${typeof fieldErrors === 'string' ? fieldErrors : JSON.stringify(fieldErrors)}`);
+                }
+            }
+        }
+        // Handle cause field
+        if (this.details.cause) {
+            const cause = this.details.cause;
+            if (typeof cause === 'string') {
+                errors.push(cause);
+            }
+            else if (typeof cause === 'object') {
+                const causeObj = cause;
+                if (causeObj.message) {
+                    errors.push(String(causeObj.message));
+                }
+                else {
+                    errors.push(JSON.stringify(cause));
+                }
+            }
+        }
+        return errors;
     }
     toMarkdown() {
         let md = `## ❌ Error: ${this.name}\n\n`;
@@ -127,11 +210,45 @@ class LatitudeApiError extends Error {
         if (this.statusCode) {
             md += `\n**HTTP Status:** ${this.statusCode}\n`;
         }
+        // Try to extract detailed errors first
+        const detailedErrors = this.getDetailedErrors();
+        if (detailedErrors.length > 0) {
+            md += `\n**Detailed Errors (${detailedErrors.length}):**\n`;
+            for (const err of detailedErrors) {
+                md += `- ${err}\n`;
+            }
+        }
+        // Always show details if present (structured data from API)
         if (this.details && Object.keys(this.details).length > 0) {
-            md += `\n**Details:**\n\`\`\`json\n${JSON.stringify(this.details, null, 2)}\n\`\`\`\n`;
+            md += `\n**API Response Details:**\n\`\`\`json\n${JSON.stringify(this.details, null, 2)}\n\`\`\`\n`;
+        }
+        // Always show raw response if available (for debugging)
+        if (this.rawResponse && this.rawResponse !== JSON.stringify(this.details)) {
+            md += `\n**Raw API Response:**\n\`\`\`json\n${this.rawResponse}\n\`\`\`\n`;
         }
         return md;
     }
+    /**
+     * Get a concise error message suitable for per-prompt error tracking
+     */
+    getConciseMessage() {
+        const detailed = this.getDetailedErrors();
+        if (detailed.length > 0) {
+            return detailed.join('; ');
+        }
+        // If no detailed errors, include details summary if available
+        if (this.details && Object.keys(this.details).length > 0) {
+            return `${this.message} | Details: ${JSON.stringify(this.details)}`;
+        }
+        // Last resort: include raw response snippet
+        if (this.rawResponse) {
+            const snippet = this.rawResponse.length > 200
+                ? this.rawResponse.substring(0, 200) + '...'
+                : this.rawResponse;
+            return `${this.message} | Raw: ${snippet}`;
+        }
+        return this.message;
+    }
 }
 exports.LatitudeApiError = LatitudeApiError;
 // ============================================================================
@@ -184,6 +301,78 @@ async function deleteDocument(versionUuid, path) {
     const normalizedPath = path.startsWith('/') ? path.slice(1) : path;
     await request(`/projects/${projectId}/versions/${versionUuid}/documents/${normalizedPath}`, { method: 'DELETE' });
 }
+/**
+ * Push changes to a version in a single batch
+ * This is the CLI-style push that sends all changes at once
+ */
+async function pushChanges(versionUuid, changes) {
+    const projectId = getProjectId();
+    // Format changes for the API
+    const apiChanges = changes.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 },
+    });
+}
+/**
+ * Compute hash of content for diff comparison
+ */
+function hashContent(content) {
+    // Simple hash - in production you might want crypto
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString(16);
+}
+/**
+ * Compute diff between incoming prompts and existing prompts
+ * Returns only the changes that need to be made
+ */
+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));
+    // Check each incoming prompt
+    for (const prompt of incoming) {
+        const existingDoc = existingMap.get(prompt.path);
+        if (!existingDoc) {
+            // New prompt
+            changes.push({
+                path: prompt.path,
+                content: prompt.content,
+                status: 'added',
+            });
+        }
+        else if (existingDoc.content !== prompt.content) {
+            // Modified prompt
+            changes.push({
+                path: prompt.path,
+                content: prompt.content,
+                status: 'modified',
+            });
+        }
+        // If content is same, 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)) {
+            changes.push({
+                path,
+                content: '',
+                status: 'deleted',
+            });
+        }
+    }
+    return changes;
+}
 async function runDocument(path, parameters, versionUuid = 'live') {
     const projectId = getProjectId();
     return request(`/projects/${projectId}/versions/${versionUuid}/documents/run`, {
@@ -197,45 +386,96 @@ async function runDocument(path, parameters, versionUuid = 'live') {
     });
 }
 /**
- * Deploy changes directly to LIVE version using force mode
- * This bypasses the draft->publish workflow which requires provider validation
+ * Format timestamp for version names: "14 Jan 2025 - 13:11"
+ * Optionally prepend action prefix like "push cover-letter"
  */
-async function deployToLive(changes, _versionName) {
-    const added = [];
-    const modified = [];
-    const deleted = [];
-    // Process each change directly to LIVE with force=true
-    for (const change of changes) {
-        logger.info(`Deploying ${change.status}: ${change.path}`);
-        if (change.status === 'deleted') {
-            try {
-                await deleteDocument('live', change.path);
-                deleted.push(change.path);
-                logger.debug(`Deleted: ${change.path}`);
-            }
-            catch (error) {
-                // Document might not exist, log and continue
-                logger.warn(`Failed to delete ${change.path}:`, error);
-            }
-        }
-        else {
-            // Use force=true to push directly to LIVE
-            await createOrUpdateDocument('live', change.path, change.content, true);
-            if (change.status === 'added') {
-                added.push(change.path);
-            }
-            else {
-                modified.push(change.path);
-            }
-            logger.debug(`${change.status}: ${change.path}`);
-        }
+function formatVersionName(prefix) {
+    const now = new Date();
+    const options = {
+        timeZone: 'America/Los_Angeles',
+        day: 'numeric',
+        month: 'short',
+        year: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    };
+    const formatted = now.toLocaleString('en-US', options);
+    // "Jan 14, 2025, 13:11" → "14 Jan 2025 - 13:11"
+    const match = formatted.match(/(\w+)\s+(\d+),\s+(\d+),\s+(\d+:\d+)/);
+    const timestamp = match
+        ? `${match[2]} ${match[1]} ${match[3]} - ${match[4]}`
+        : now.toISOString().replace(/[:.]/g, '-');
+    return prefix ? `${prefix} (${timestamp})` : timestamp;
+}
+/**
+ * Create a synthetic Version object for no-op deploys.
+ * Returns a fully populated Version with all required fields.
+ */
+function createNoOpVersion() {
+    const now = new Date().toISOString();
+    return {
+        id: 0,
+        uuid: 'live',
+        projectId: 0,
+        message: 'No changes to deploy',
+        createdAt: now,
+        updatedAt: now,
+        status: 'live',
+    };
+}
+/**
+ * Deploy changes to LIVE version using the proper workflow:
+ * 1. Create a draft version
+ * 2. Push all changes to the draft (batch)
+ * 3. Publish the draft to make it LIVE
+ *
+ * This is the same workflow the CLI uses, ensuring proper validation.
+ */
+async function deployToLive(changes, versionName) {
+    if (changes.length === 0) {
+        logger.info('No changes to deploy');
+        return {
+            version: createNoOpVersion(),
+            documentsProcessed: 0,
+            added: [],
+            modified: [],
+            deleted: [],
+        };
+    }
+    // Filter out unchanged items (they shouldn't be sent to API)
+    const actualChanges = changes.filter(c => c.status !== 'unchanged');
+    if (actualChanges.length === 0) {
+        logger.info('All prompts are unchanged, nothing to deploy');
+        return {
+            version: createNoOpVersion(),
+            documentsProcessed: 0,
+            added: [],
+            modified: [],
+            deleted: [],
+        };
     }
-    // Get current LIVE version info
-    const docs = await listDocuments('live');
-    const liveVersionUuid = docs.length > 0 ? docs[0].versionUuid : 'live';
+    // Categorize changes for logging and return value
+    const added = actualChanges.filter((c) => c.status === 'added').map((c) => c.path);
+    const modified = actualChanges.filter((c) => c.status === 'modified').map((c) => c.path);
+    const deleted = actualChanges.filter((c) => c.status === 'deleted').map((c) => c.path);
+    const name = formatVersionName(versionName);
+    logger.info(`Deploying to LIVE: ${added.length} added, ${modified.length} modified, ${deleted.length} deleted`);
+    // Step 1: Create a new draft version
+    logger.info(`Creating draft version: ${name}`);
+    const draft = await createVersion(name);
+    logger.info(`Draft created: ${draft.uuid}`);
+    // Step 2: Push all changes to the draft in ONE batch
+    logger.info(`Pushing ${actualChanges.length} change(s) to draft...`);
+    const pushResult = await pushChanges(draft.uuid, actualChanges);
+    logger.info(`Push complete: ${pushResult.documentsProcessed} documents processed`);
+    // Step 3: Publish the draft to make it LIVE
+    logger.info(`Publishing draft ${draft.uuid} to LIVE...`);
+    const published = await publishVersion(draft.uuid, name);
+    logger.info(`Published successfully! Version is now LIVE: ${published.uuid}`);
     return {
-        version: { uuid: liveVersionUuid },
-        documentsProcessed: changes.length,
+        version: published,
+        documentsProcessed: pushResult.documentsProcessed,
         added,
         modified,
         deleted,

package/dist/tools.js

@@ -194,53 +194,52 @@ async function handlePushPrompts(args) {
         if (prompts.length === 0) {
             return formatError(new Error('No prompts provided. Use either prompts array or filePaths.'));
         }
-        // Get existing prompts to delete
+        // Get existing prompts for diff computation
         const existingDocs = await (0, api_js_1.listDocuments)('live');
-        const existingNames = existingDocs.map((d) => d.path);
-        // Step 1: Delete all existing prompts in one batch (deletions are small)
-        if (existingNames.length > 0) {
-            const deleteChanges = existingNames.map((name) => ({
-                path: name,
-                content: '',
-                status: 'deleted',
-            }));
-            await (0, api_js_1.deployToLive)(deleteChanges, 'push (delete existing)');
+        // Compute diff - this determines what needs to be added, modified, or deleted
+        const incoming = prompts.map(p => ({ path: p.name, content: p.content }));
+        const changes = (0, api_js_1.computeDiff)(incoming, existingDocs);
+        // Summarize changes
+        const added = changes.filter((c) => c.status === 'added');
+        const modified = changes.filter((c) => c.status === 'modified');
+        const deleted = changes.filter((c) => c.status === 'deleted');
+        if (changes.length === 0) {
+            const newNames = await forceRefreshAndGetNames();
+            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(', ')}`);
         }
-        // Step 2: Add each new prompt INDIVIDUALLY to avoid payload size limits
-        const added = [];
-        const errors = [];
-        for (const prompt of prompts) {
-            try {
-                const changes = [
-                    {
-                        path: prompt.name,
-                        content: prompt.content,
-                        status: 'added',
-                    },
-                ];
-                await (0, api_js_1.deployToLive)(changes, `push ${prompt.name}`);
-                added.push(prompt.name);
+        // Push all changes in one batch
+        try {
+            const result = await (0, api_js_1.deployToLive)(changes, 'push');
+            // Force refresh cache after mutations
+            const newNames = await forceRefreshAndGetNames();
+            let content = `**Summary:**\n`;
+            content += `- Added: ${added.length}\n`;
+            content += `- Modified: ${modified.length}\n`;
+            content += `- Deleted: ${deleted.length}\n`;
+            content += `- Documents processed: ${result.documentsProcessed}\n\n`;
+            if (added.length > 0) {
+                content += `### Added\n${added.map((c) => `- \`${c.path}\``).join('\n')}\n\n`;
             }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                errors.push(`${prompt.name}: ${msg}`);
+            if (modified.length > 0) {
+                content += `### Modified\n${modified.map((c) => `- \`${c.path}\``).join('\n')}\n\n`;
             }
+            if (deleted.length > 0) {
+                content += `### Deleted\n${deleted.map((c) => `- \`${c.path}\``).join('\n')}\n\n`;
+            }
+            content += `---\n**Current LIVE prompts (${newNames.length}):** ${newNames.map(n => `\`${n}\``).join(', ')}`;
+            return formatSuccess('Prompts Pushed to LIVE', content);
         }
-        // Force refresh cache after mutations
-        const newNames = await forceRefreshAndGetNames();
-        let content = `**Deleted:** ${existingNames.length} prompt(s)\n`;
-        content += `**Added:** ${added.length} prompt(s)\n`;
-        if (errors.length > 0) {
-            content += `**Errors:** ${errors.length}\n`;
-            content += errors.map((e) => `  - ${e}`).join('\n') + '\n';
-        }
-        content += `\n### Deployed Prompts\n\n`;
-        content += added.map((n) => `- \`${n}\``).join('\n');
-        content += `\n\n---\n**Current LIVE prompts (${newNames.length}):** ${newNames.map(n => `\`${n}\``).join(', ')}`;
-        if (added.length === 0 && errors.length > 0) {
-            return formatError(new Error(`All ${errors.length} prompt(s) failed:\n${errors.join('\n')}`));
+        catch (error) {
+            // Detailed error from API
+            if (error instanceof api_js_1.LatitudeApiError) {
+                return {
+                    content: [{ type: 'text', text: error.toMarkdown() }],
+                    isError: true,
+                };
+            }
+            throw error;
         }
-        return formatSuccess('Prompts Pushed to LIVE', content);
     }
     catch (error) {
         return formatError(error);
@@ -282,64 +281,85 @@ async function handleAppendPrompts(args) {
         }
         // Get existing prompts
         const existingDocs = await (0, api_js_1.listDocuments)('live');
-        const existingNames = new Set(existingDocs.map((d) => d.path));
-        // Track results
-        const added = [];
-        const updated = [];
+        const existingMap = new Map(existingDocs.map((d) => [d.path, d]));
+        // Build changes - append does NOT delete existing prompts
+        const changes = [];
         const skipped = [];
-        const errors = [];
-        // Process each prompt INDIVIDUALLY to avoid payload size limits
         for (const prompt of prompts) {
-            const exists = existingNames.has(prompt.name);
-            if (exists && !args.overwrite) {
-                skipped.push(prompt.name);
-                continue;
-            }
-            try {
-                const changes = [
-                    {
-                        path: prompt.name,
-                        content: prompt.content,
-                        status: exists ? 'modified' : 'added',
-                    },
-                ];
-                await (0, api_js_1.deployToLive)(changes, `append ${prompt.name}`);
-                if (exists) {
-                    updated.push(prompt.name);
+            const existingDoc = existingMap.get(prompt.name);
+            if (existingDoc) {
+                if (args.overwrite) {
+                    // Only include if content is different
+                    if (existingDoc.content !== prompt.content) {
+                        changes.push({
+                            path: prompt.name,
+                            content: prompt.content,
+                            status: 'modified',
+                        });
+                    }
+                    // If same content, skip silently (unchanged)
                 }
                 else {
-                    added.push(prompt.name);
+                    skipped.push(prompt.name);
                 }
             }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                errors.push(`${prompt.name}: ${msg}`);
+            else {
+                // New prompt
+                changes.push({
+                    path: prompt.name,
+                    content: prompt.content,
+                    status: 'added',
+                });
             }
         }
-        // Force refresh cache after mutations
-        const newNames = await forceRefreshAndGetNames();
-        let content = '';
-        if (added.length > 0) {
-            content += `**Added:** ${added.length}\n`;
-            content += added.map((n) => `  - \`${n}\``).join('\n') + '\n\n';
-        }
-        if (updated.length > 0) {
-            content += `**Updated:** ${updated.length}\n`;
-            content += updated.map((n) => `  - \`${n}\``).join('\n') + '\n\n';
+        // Summarize
+        const added = changes.filter((c) => c.status === 'added');
+        const modified = changes.filter((c) => c.status === 'modified');
+        if (changes.length === 0 && skipped.length === 0) {
+            const newNames = await forceRefreshAndGetNames();
+            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(', ')}`);
         }
-        if (skipped.length > 0) {
-            content += `**Skipped:** ${skipped.length} (already exist)\n`;
+        if (changes.length === 0) {
+            const newNames = await forceRefreshAndGetNames();
+            let content = `**Skipped:** ${skipped.length} (already exist, use overwrite=true to update)\n`;
+            content += `\n---\n**Current LIVE prompts (${newNames.length}):** ${newNames.map(n => `\`${n}\``).join(', ')}`;
+            return formatSuccess('No Changes Made', content);
         }
-        if (errors.length > 0) {
-            content += `\n**Errors:** ${errors.length}\n`;
-            content += errors.map((e) => `  - ${e}`).join('\n') + '\n';
+        // Push all changes in one batch
+        try {
+            const result = await (0, api_js_1.deployToLive)(changes, 'append');
+            // Force refresh cache after mutations
+            const newNames = await forceRefreshAndGetNames();
+            let content = `**Summary:**\n`;
+            content += `- Added: ${added.length}\n`;
+            content += `- Updated: ${modified.length}\n`;
+            if (skipped.length > 0) {
+                content += `- Skipped: ${skipped.length} (use overwrite=true)\n`;
+            }
+            content += `- Documents processed: ${result.documentsProcessed}\n\n`;
+            if (added.length > 0) {
+                content += `### Added\n${added.map((c) => `- \`${c.path}\``).join('\n')}\n\n`;
+            }
+            if (modified.length > 0) {
+                content += `### Updated\n${modified.map((c) => `- \`${c.path}\``).join('\n')}\n\n`;
+            }
+            if (skipped.length > 0) {
+                content += `### Skipped (already exist)\n${skipped.map(n => `- \`${n}\``).join('\n')}\n\n`;
+            }
+            content += `---\n**Current LIVE prompts (${newNames.length}):** ${newNames.map(n => `\`${n}\``).join(', ')}`;
+            return formatSuccess('Prompts Appended to LIVE', content);
         }
-        content += `\n---\n**Current LIVE prompts (${newNames.length}):** ${newNames.map(n => `\`${n}\``).join(', ')}`;
-        const totalProcessed = added.length + updated.length;
-        if (totalProcessed === 0 && errors.length > 0) {
-            return formatError(new Error(`All ${errors.length} prompt(s) failed:\n${errors.join('\n')}`));
+        catch (error) {
+            // Detailed error from API
+            if (error instanceof api_js_1.LatitudeApiError) {
+                return {
+                    content: [{ type: 'text', text: error.toMarkdown() }],
+                    isError: true,
+                };
+            }
+            throw error;
         }
-        return formatSuccess('Prompts Appended to LIVE', content);
     }
     catch (error) {
         return formatError(error);

package/dist/types.d.ts

@@ -33,7 +33,7 @@ export interface Document {
 export interface DocumentChange {
     path: string;
     content: string;
-    status: 'added' | 'modified' | 'deleted';
+    status: 'added' | 'modified' | 'deleted' | 'unchanged';
 }
 export interface DeployResult {
     version: Version;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "latitude-mcp-server",
-	"version": "2.1.7",
+	"version": "2.2.1",
 	"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",