editmamei 0.22.4 → 0.24.1

package/dist/tools/group-tools.js

@@ -1,6 +1,11 @@
 import { runScript } from '../utils/run-script.js';
 import { GROUP_BLEND_MODES } from '../utils/blend-modes.js';
 import { validateArgs } from '../utils/validate.js';
+import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
+const emptySchema = {
+    type: 'object',
+    properties: {},
+};
 const deleteGroupSchema = {
     type: 'object',
     properties: {
@@ -27,6 +32,11 @@ const createGroupSchema = {
             items: { type: 'string' },
             description: 'Optional list of existing layer names to move into the new group. The first listed name ends up on top of the group stack. Layers not found are returned in `not_found`.',
         },
+        into_active_group: {
+            type: 'boolean',
+            description: "Photoshop's Mk-layerSection descriptor carries no placement target, so with a GROUP active it would natively nest the new group INSIDE that group. Default false hoists the new group back out so it lands above the active layer/group as a sibling, matching this tool's documented placement. Pass true to keep it nested inside the active group instead.",
+            default: false,
+        },
     },
     required: ['name'],
 };
@@ -78,7 +88,7 @@ export function createGroupTools(connection, snippetClient) {
         {
             tool: {
                 name: 'ps_create_group',
-                description: 'Create a new layer group (LayerSet) above the active layer with the given name. Optionally moves existing layers into it in one step. Non-destructive. Foundational for structured non-destructive editing — e.g. group all adjustment layers into an "edits" group so you can A/B toggle the whole stack via group visibility.',
+                description: `Create a new layer group (LayerSet) above the active layer with the given name — hoisted out of the active layer's group by default even though Photoshop's own Mk-layerSection placement rule would otherwise nest it INSIDE that group (pass into_active_group:true to keep that native nesting; this is why groups created one after another land as siblings rather than nested, so bottom-to-top group creation is safe). Optionally moves existing layers into it in one step. Non-destructive. Foundational for structured non-destructive editing — e.g. group all adjustment layers into an "edits" group so you can A/B toggle the whole stack via group visibility.`,
                 inputSchema: createGroupSchema,
                 outputSchema: {
                     type: 'object',
@@ -87,6 +97,15 @@ export function createGroupTools(connection, snippetClient) {
                         groupName: { type: 'string' },
                         moved_count: { type: 'number' },
                         not_found: { type: 'array', items: { type: 'string' } },
+                        hoisted: {
+                            type: 'boolean',
+                            description: 'True when the new group had to be moved back out of the previously-active group to honor into_active_group:false (the default). False when it landed correctly on its own, or when the move-back itself failed — check the layer tree if this matters and hoisted is false.',
+                        },
+                        parent_path: {
+                            type: ['array', 'null'],
+                            items: { type: 'string' },
+                            description: 'The containing-group name chain (outermost first), empty array at the document root.',
+                        },
                         context: { type: 'object' },
                     },
                 },
@@ -226,150 +245,81 @@ export function createGroupTools(connection, snippetClient) {
         },
     ];
 }
-async function createClippingMask(connection, snippetClient, _rawArgs) {
-    try {
-        const script = await snippetClient.build('createClippingMask');
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Clipped layer "${result.layerName ?? ''}" to the layer below.`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error creating clipping mask: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+async function createClippingMask(connection, snippetClient, rawArgs) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: emptySchema,
+        snippet: 'createClippingMask',
+        errorPrefix: 'Error creating clipping mask',
+        successText: (result) => `Clipped layer "${result.layerName ?? ''}" to the layer below.`,
+    });
 }
-async function releaseClippingMask(connection, snippetClient, _rawArgs) {
-    try {
-        const script = await snippetClient.build('releaseClippingMask');
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Released clipping mask on layer "${result.layerName ?? ''}".`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error releasing clipping mask: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+async function releaseClippingMask(connection, snippetClient, rawArgs) {
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: emptySchema,
+        snippet: 'releaseClippingMask',
+        errorPrefix: 'Error releasing clipping mask',
+        successText: (result) => `Released clipping mask on layer "${result.layerName ?? ''}".`,
+    });
 }
 async function createGroup(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(createGroupSchema, rawArgs);
-        const name = args.name;
-        const layers = args.layers;
-        const params = { name };
-        if (layers !== undefined)
-            params.layerNames = layers;
-        const script = await snippetClient.build('createGroup', params);
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Group "${name}" created${layers && layers.length ? ` (moved ${result.moved_count ?? 0}/${layers.length} layers)` : ''}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error creating group: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: createGroupSchema,
+        snippet: 'createGroup',
+        errorPrefix: 'Error creating group',
+        params: (args) => {
+            const name = args.name;
+            const layers = args.layers;
+            const intoActiveGroup = args.into_active_group ?? false;
+            const params = { name, into_active_group: intoActiveGroup };
+            if (layers !== undefined)
+                params.layerNames = layers;
+            return params;
+        },
+        successText: (result, args) => {
+            const name = args.name;
+            const layers = args.layers;
+            return `Group "${name}" created${layers && layers.length ? ` (moved ${result.moved_count ?? 0}/${layers.length} layers)` : ''}`;
+        },
+    });
 }
 async function moveLayerToGroup(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(moveLayerToGroupSchema, rawArgs);
-        const layerName = args.layer_name;
-        const groupName = args.group_name;
-        const script = await snippetClient.build('moveLayerToGroup', { layerName, groupName });
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Layer "${layerName}" moved into group "${groupName}"`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error moving layer to group: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: moveLayerToGroupSchema,
+        snippet: 'moveLayerToGroup',
+        errorPrefix: 'Error moving layer to group',
+        params: (args) => ({
+            layerName: args.layer_name,
+            groupName: args.group_name,
+        }),
+        successText: (_result, args) => `Layer "${args.layer_name}" moved into group "${args.group_name}"`,
+    });
 }
 async function setGroupBlendMode(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(setGroupBlendModeSchema, rawArgs);
-        const name = args.name;
-        const blendMode = args.blend_mode;
-        const script = await snippetClient.build('setGroupBlendMode', {
-            groupName: name,
-            blendMode,
-        });
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Group "${name}" blend mode set to ${blendMode}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error setting group blend mode: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: setGroupBlendModeSchema,
+        snippet: 'setGroupBlendMode',
+        errorPrefix: 'Error setting group blend mode',
+        params: (args) => ({
+            groupName: args.name,
+            blendMode: args.blend_mode,
+        }),
+        successText: (_result, args) => `Group "${args.name}" blend mode set to ${args.blend_mode}`,
+    });
 }
 async function ungroup(connection, snippetClient, rawArgs) {
     try {
@@ -400,15 +350,7 @@ async function ungroup(connection, snippetClient, rawArgs) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error ungrouping: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        return toolErrorResult('Error ungrouping', error);
     }
 }
 async function deleteGroup(connection, snippetClient, rawArgs) {
@@ -440,14 +382,6 @@ async function deleteGroup(connection, snippetClient, rawArgs) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error deleting group: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        return toolErrorResult('Error deleting group', error);
     }
 }

package/dist/tools/guide-tools.js

@@ -1,5 +1,4 @@
-import { runScript } from '../utils/run-script.js';
-import { validateArgs } from '../utils/validate.js';
+import { runSnippetTool } from '../utils/tool-helpers.js';
 const addGuideSchema = {
     type: 'object',
     properties: {
@@ -33,6 +32,10 @@ const guideLayoutSchema = {
         },
     },
 };
+const clearGuidesSchema = {
+    type: 'object',
+    properties: {},
+};
 const GUIDE_OPS = ['add', 'layout', 'clear'];
 const GUIDE_INPUT_SCHEMA = {
     type: 'object',
@@ -98,89 +101,55 @@ async function guides(connection, snippetClient, rawArgs) {
     }
 }
 async function addGuide(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(addGuideSchema, rawArgs);
-        const orientation = args.orientation;
-        const position = args.position;
-        const script = await snippetClient.build('addGuide', { orientation, position });
-        const result = (await runScript(connection, script));
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Added ${orientation} guide at ${position}px\nResult: ${JSON.stringify(result)}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error adding guide: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: addGuideSchema,
+        snippet: 'addGuide',
+        errorPrefix: 'Error adding guide',
+        params: (args) => ({
+            orientation: args.orientation,
+            position: args.position,
+        }),
+        successText: (result, args) => {
+            const orientation = args.orientation;
+            const position = args.position;
+            return `Added ${orientation} guide at ${position}px\nResult: ${JSON.stringify(result)}`;
+        },
+    });
 }
 async function addGuideLayout(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(guideLayoutSchema, rawArgs);
-        const columns = args.columns ?? 0;
-        const rows = args.rows ?? 0;
-        if (columns <= 0 && rows <= 0) {
-            throw new Error('op=layout requires at least one of columns / rows to be ≥ 1.');
-        }
-        const script = await snippetClient.build('addGuideLayout', { columns, rows });
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Created guide layout (${columns} columns × ${rows} rows)\nResult: ${JSON.stringify(result)}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error creating guide layout: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: guideLayoutSchema,
+        snippet: 'addGuideLayout',
+        errorPrefix: 'Error creating guide layout',
+        params: (args) => {
+            const columns = args.columns ?? 0;
+            const rows = args.rows ?? 0;
+            if (columns <= 0 && rows <= 0) {
+                throw new Error('op=layout requires at least one of columns / rows to be ≥ 1.');
+            }
+            return { columns, rows };
+        },
+        successText: (result, args) => {
+            const columns = args.columns ?? 0;
+            const rows = args.rows ?? 0;
+            return `Created guide layout (${columns} columns × ${rows} rows)\nResult: ${JSON.stringify(result)}`;
+        },
+    });
 }
 async function clearGuides(connection, snippetClient) {
-    try {
-        const script = await snippetClient.build('clearGuides', {});
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Cleared all guides\nResult: ${JSON.stringify(result)}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error clearing guides: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs: {},
+        schema: clearGuidesSchema,
+        snippet: 'clearGuides',
+        errorPrefix: 'Error clearing guides',
+        successText: (result) => `Cleared all guides\nResult: ${JSON.stringify(result)}`,
+    });
 }

package/dist/tools/history-tools.js

@@ -1,5 +1,5 @@
 import { runScript } from '../utils/run-script.js';
-import { validateArgs } from '../utils/validate.js';
+import { toolErrorResult, runSnippetTool } from '../utils/tool-helpers.js';
 const undoSchema = {
     type: 'object',
     properties: {
@@ -39,7 +39,7 @@ export function createHistoryTools(connection, snippetClient) {
         {
             tool: {
                 name: 'ps_undo',
-                description: 'Step backward in the document history (equivalent to Ctrl/Cmd+Z). WHEN TO REACH FOR THIS: after an experimental destructive bake (photoshop_merge_visible_layers, photoshop_flatten_image, photoshop_apply_*_blur, photoshop_apply_sharpen, photoshop_apply_noise) produced a wrong result; after a play_action whose scope you mispredicted; or to revert an entire branch of exploration. Non-destructive workflows (adjustment layers + masks) rarely need this — just tweak/delete the offending layer instead. Reversible via ps_redo as long as no new edit has been made since. Returns current history state, remaining steps, and document context.',
+                description: 'Step backward in the document history (equivalent to Ctrl/Cmd+Z). WHEN TO REACH FOR THIS: after an experimental destructive bake (ps_merge mode=visible/flatten, ps_apply_filter type=*_blur/sharpen/noise) produced a wrong result; after a play_action whose scope you mispredicted; or to revert an entire branch of exploration. Non-destructive workflows (adjustment layers + masks) rarely need this — just tweak/delete the offending layer instead. Reversible via ps_redo as long as no new edit has been made since. Returns current history state, remaining steps, and document context.',
                 inputSchema: undoSchema,
                 outputSchema: HISTORY_STEP_RESULT_SCHEMA,
                 annotations: {
@@ -65,60 +65,34 @@ export function createHistoryTools(connection, snippetClient) {
     ];
 }
 async function undo(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(undoSchema, rawArgs);
-        const steps = args.steps;
-        const script = await snippetClient.build('undo', { steps });
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Undo successful (${steps} step${steps > 1 ? 's' : ''})\nResult: ${JSON.stringify(result)}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error undoing: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: undoSchema,
+        snippet: 'undo',
+        errorPrefix: 'Error undoing',
+        params: (args) => ({ steps: args.steps }),
+        successText: (result, args) => {
+            const steps = args.steps;
+            return `Undo successful (${steps} step${steps > 1 ? 's' : ''})\nResult: ${JSON.stringify(result)}`;
+        },
+    });
 }
 async function redo(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(redoSchema, rawArgs);
-        const steps = args.steps;
-        const script = await snippetClient.build('redo', { steps });
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Redo successful (${steps} step${steps > 1 ? 's' : ''})\nResult: ${JSON.stringify(result)}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error redoing: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: redoSchema,
+        snippet: 'redo',
+        errorPrefix: 'Error redoing',
+        params: (args) => ({ steps: args.steps }),
+        successText: (result, args) => {
+            const steps = args.steps;
+            return `Redo successful (${steps} step${steps > 1 ? 's' : ''})\nResult: ${JSON.stringify(result)}`;
+        },
+    });
 }
 export async function getHistory(connection, snippetClient) {
     try {
@@ -135,14 +109,6 @@ export async function getHistory(connection, snippetClient) {
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error getting history: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
+        return toolErrorResult('Error getting history', error);
     }
 }

package/dist/tools/image-placement-tools.js

@@ -1,5 +1,4 @@
-import { runScript } from '../utils/run-script.js';
-import { validateArgs } from '../utils/validate.js';
+import { runSnippetTool } from '../utils/tool-helpers.js';
 const PS_COORD_MAX_PX = 300_000;
 const placeImageSchema = {
     type: 'object',
@@ -65,39 +64,21 @@ export function createImagePlacementTools(connection, snippetClient) {
     ];
 }
 async function placeImage(connection, snippetClient, rawArgs) {
-    try {
-        const args = validateArgs(placeImageSchema, rawArgs);
-        const filePath = args.file_path;
-        const x = args.x;
-        const y = args.y;
-        const widthPercent = args.width_percent;
-        const heightPercent = args.height_percent;
-        const params = { filePath, x, y };
-        if (widthPercent !== undefined)
-            params.widthPercent = widthPercent;
-        if (heightPercent !== undefined)
-            params.heightPercent = heightPercent;
-        const script = await snippetClient.build('placeImage', params);
-        const result = await runScript(connection, script);
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Image placed successfully: ${filePath}\nPosition: (${x}, ${y})\nResult: ${JSON.stringify(result)}`,
-                },
-            ],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error placing image: ${error instanceof Error ? error.message : String(error)}`,
-                },
-            ],
-            isError: true,
-        };
-    }
+    return runSnippetTool({
+        connection,
+        snippetClient,
+        rawArgs,
+        schema: placeImageSchema,
+        snippet: 'placeImage',
+        errorPrefix: 'Error placing image',
+        params: (args) => {
+            const params = { filePath: args.file_path, x: args.x, y: args.y };
+            if (args.width_percent !== undefined)
+                params.widthPercent = args.width_percent;
+            if (args.height_percent !== undefined)
+                params.heightPercent = args.height_percent;
+            return params;
+        },
+        successText: (result, args) => `Image placed successfully: ${args.file_path}\nPosition: (${args.x}, ${args.y})\nResult: ${JSON.stringify(result)}`,
+    });
 }