editmamei 0.17.4 → 0.18.0

package/dist/tools/guide-tools.js

@@ -0,0 +1,186 @@
+import { runScript } from '../utils/run-script.js';
+import { validateArgs } from '../utils/validate.js';
+const addGuideSchema = {
+    type: 'object',
+    properties: {
+        orientation: {
+            type: 'string',
+            enum: ['horizontal', 'vertical'],
+            description: "'vertical' adds a top-to-bottom guide positioned by its x coordinate; 'horizontal' adds a left-to-right guide positioned by its y coordinate.",
+        },
+        position: {
+            type: 'number',
+            description: 'Guide position in document pixels (the x for vertical, the y for horizontal).',
+            minimum: 0,
+        },
+    },
+    required: ['orientation', 'position'],
+};
+const guideLayoutSchema = {
+    type: 'object',
+    properties: {
+        columns: {
+            type: 'integer',
+            description: 'Number of evenly-spaced columns (vertical guides). 0 = none.',
+            minimum: 0,
+            default: 0,
+        },
+        rows: {
+            type: 'integer',
+            description: 'Number of evenly-spaced rows (horizontal guides). 0 = none.',
+            minimum: 0,
+            default: 0,
+        },
+    },
+};
+const GUIDE_OPS = ['add', 'layout', 'clear'];
+const GUIDE_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        op: {
+            type: 'string',
+            enum: [...GUIDE_OPS],
+            description: 'Guide operation. add: one guide at position (orientation + position px). layout: an evenly-spaced grid (columns and/or rows). clear: remove ALL guides from the document.',
+        },
+        ...addGuideSchema.properties,
+        ...guideLayoutSchema.properties,
+    },
+    required: ['op'],
+};
+export function createGuideTools(connection, snippetClient) {
+    return [
+        {
+            tool: {
+                name: 'photoshop_guides',
+                description: 'Manage document guides — choose with `op`. `add` places one guide (orientation horizontal|vertical + position in px). `layout` creates an evenly-spaced grid (columns and/or rows — great for rule-of-thirds at 3×3). `clear` removes all guides. Guides are non-printing layout aids.',
+                inputSchema: GUIDE_INPUT_SCHEMA,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        guide_added: { type: 'boolean' },
+                        guide_layout_created: { type: 'boolean' },
+                        guides_cleared: { type: 'boolean' },
+                        orientation: { type: 'string' },
+                        position: { type: 'number' },
+                        columns: { type: 'number' },
+                        rows: { type: 'number' },
+                    },
+                },
+                annotations: {
+                    title: 'Document Guides',
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => guides(connection, snippetClient, args),
+        },
+    ];
+}
+async function guides(connection, snippetClient, rawArgs) {
+    const op = rawArgs.op;
+    const { op: _omit, ...rest } = rawArgs;
+    switch (op) {
+        case 'add':
+            return addGuide(connection, snippetClient, rest);
+        case 'layout':
+            return addGuideLayout(connection, snippetClient, rest);
+        case 'clear':
+            return clearGuides(connection, snippetClient);
+        default:
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: unknown guides op "${String(op)}". Allowed: ${GUIDE_OPS.join(', ')}.`,
+                    },
+                ],
+                isError: true,
+            };
+    }
+}
+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,
+        };
+    }
+}
+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,
+        };
+    }
+}
+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,
+        };
+    }
+}

package/dist/tools/history-tools.js

@@ -22,10 +22,6 @@ const redoSchema = {
         },
     },
 };
-const emptySchema = {
-    type: 'object',
-    properties: {},
-};
 const HISTORY_STEP_RESULT_SCHEMA = {
     type: 'object',
     properties: {
@@ -66,40 +62,6 @@ export function createHistoryTools(connection, snippetClient) {
             },
             handler: async (args) => redo(connection, snippetClient, args),
         },
-        {
-            tool: {
-                name: 'photoshop_get_history',
-                description: 'List all history states for the active document along with the current cursor position. Read-only. Useful for deciding how far back to undo or for diagnostics. Returns document context as part of the snapshot.',
-                inputSchema: emptySchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        totalStates: { type: 'number' },
-                        currentIndex: { type: 'number' },
-                        currentState: { type: 'string' },
-                        canUndo: { type: 'boolean' },
-                        canRedo: { type: 'boolean' },
-                        states: {
-                            type: 'array',
-                            items: {
-                                type: 'object',
-                                properties: {
-                                    name: { type: 'string' },
-                                    snapshot: { type: 'boolean' },
-                                },
-                            },
-                        },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Get History States',
-                    readOnlyHint: true,
-                    idempotentHint: true,
-                },
-            },
-            handler: async () => getHistory(connection, snippetClient),
-        },
     ];
 }
 async function undo(connection, snippetClient, rawArgs) {
@@ -158,7 +120,7 @@ async function redo(connection, snippetClient, rawArgs) {
         };
     }
 }
-async function getHistory(connection, snippetClient) {
+export async function getHistory(connection, snippetClient) {
     try {
         const script = await snippetClient.build('getHistoryStates');
         const result = await runScript(connection, script);

package/dist/tools/image-tools.js

@@ -49,6 +49,37 @@ const cropDocumentSchema = {
     },
     required: ['left', 'top', 'right', 'bottom'],
 };
+const convertImageModeSchema = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['grayscale', 'rgb', 'cmyk', 'lab', 'bitmap'],
+            description: 'Target document color mode. grayscale discards color (the "Discard color information?" prompt is auto-confirmed); the document is FLATTENED as part of the conversion. `bitmap` produces a 1-bit halftone-screen image (auto-converts to grayscale first) — use frequency/angle/shape.',
+        },
+        frequency: {
+            type: 'number',
+            description: 'bitmap only: halftone screen frequency in lines/inch (1-999). PS default 53.',
+            minimum: 1,
+            maximum: 999,
+            default: 53,
+        },
+        angle: {
+            type: 'number',
+            description: 'bitmap only: halftone screen angle in degrees (-180 to 180). PS default 45.',
+            minimum: -180,
+            maximum: 180,
+            default: 45,
+        },
+        shape: {
+            type: 'string',
+            enum: ['round', 'diamond', 'ellipse', 'line', 'square', 'cross'],
+            description: 'bitmap only: halftone dot shape.',
+            default: 'round',
+        },
+    },
+    required: ['mode'],
+};
 export function createImageTools(connection, snippetClient) {
     return [
         {
@@ -96,6 +127,29 @@ export function createImageTools(connection, snippetClient) {
             },
             handler: async (args) => cropDocument(connection, snippetClient, args),
         },
+        {
+            tool: {
+                name: 'photoshop_convert_image_mode',
+                description: 'Convert the document color mode (grayscale / rgb / cmyk / lab). Destructive and document-wide: the image is FLATTENED and, for grayscale, color is discarded (the confirmation prompt is auto-accepted). Use grayscale as the base for halftone / line-art workflows, or rgb to bring a CMYK/Lab doc back for normal editing. Returns updated document context.',
+                inputSchema: convertImageModeSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        converted: { type: 'boolean' },
+                        requested_mode: { type: 'string' },
+                        mode_before: { type: 'string' },
+                        mode_after: { type: 'string' },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Convert Image Mode (destructive)',
+                    destructiveHint: true,
+                    idempotentHint: true,
+                },
+            },
+            handler: async (args) => convertImageMode(connection, snippetClient, args),
+        },
     ];
 }
 async function resizeImage(connection, snippetClient, rawArgs) {
@@ -130,6 +184,40 @@ async function resizeImage(connection, snippetClient, rawArgs) {
         };
     }
 }
+async function convertImageMode(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(convertImageModeSchema, rawArgs);
+        const mode = args.mode;
+        const params = { mode };
+        if (mode === 'bitmap') {
+            params.frequency = args.frequency ?? 53;
+            params.angle = args.angle ?? 45;
+            params.shape = args.shape ?? 'round';
+        }
+        const script = await snippetClient.build('convertImageMode', params);
+        const result = await runScript(connection, script);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Document converted to ${mode} mode.`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error converting image mode: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
 async function cropDocument(connection, snippetClient, rawArgs) {
     try {
         const args = validateArgs(cropDocumentSchema, rawArgs);

package/dist/tools/inspect-tools.js

@@ -0,0 +1,86 @@
+import { getMetadata, getMetadataSchema } from './metadata-tools.js';
+import { getHistory } from './history-tools.js';
+import { getLayerTree } from './layer-tools.js';
+import { getSelectionInfoHandler } from './selection-tools.js';
+const INSPECT_WHATS = ['metadata', 'layer_tree', 'history', 'selection_info'];
+const INSPECT_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        what: {
+            type: 'string',
+            enum: [...INSPECT_WHATS],
+            description: 'Which read-only state to return. ' +
+                'metadata: document/IPTC/camera-EXIF/GPS/ACR develop settings + active context (optionally subset with `sections`; sections=["context"] is the cheap orientation probe). ' +
+                'layer_tree: the full recursive layer tree (name/kind/visibility/opacity/blend/clipping/bounds) — use whenever you need what is inside a group. ' +
+                'history: all history states + the current cursor, for deciding how far to undo. ' +
+                'selection_info: current selection bounds/coverage/edge-complexity without modifying anything.',
+        },
+        ...getMetadataSchema.properties,
+    },
+    required: ['what'],
+};
+export function createInspectTools(connection, snippetClient) {
+    return [
+        {
+            tool: {
+                name: 'photoshop_inspect',
+                description: 'Read-only document inspection — choose with `what` (metadata / layer_tree / history / selection_info). This is the assess/orientation surface: call it at the start of a workflow and whenever you need fresh state. For metadata, pass `sections` to subset (e.g. ["context"] for a cheap probe). For an IMAGE-based check use photoshop_get_preview; for NUMERIC verification use photoshop_get_histogram / photoshop_compare_regions / photoshop_get_layer_bounds_diff (these stay separate, named tools on purpose). Read-only and idempotent.',
+                inputSchema: INSPECT_INPUT_SCHEMA,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        document: { type: 'object' },
+                        iptc: { type: 'object' },
+                        camera: { type: 'object' },
+                        gps: { type: 'object' },
+                        acr: { type: 'object' },
+                        source_metadata: { type: 'object' },
+                        context: { type: 'object' },
+                        documentName: { type: 'string' },
+                        activeLayer: { type: 'string' },
+                        topLevelCount: { type: 'number' },
+                        tree: { type: 'array' },
+                        totalStates: { type: 'number' },
+                        currentIndex: { type: 'number' },
+                        currentState: { type: 'string' },
+                        canUndo: { type: 'boolean' },
+                        canRedo: { type: 'boolean' },
+                        states: { type: 'array' },
+                        selection_info: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Inspect Document State',
+                    readOnlyHint: true,
+                    idempotentHint: true,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => inspect(connection, snippetClient, args),
+        },
+    ];
+}
+async function inspect(connection, snippetClient, rawArgs) {
+    const what = rawArgs.what;
+    const { what: _omit, ...rest } = rawArgs;
+    switch (what) {
+        case 'metadata':
+            return getMetadata(connection, snippetClient, rest);
+        case 'layer_tree':
+            return getLayerTree(connection, snippetClient);
+        case 'history':
+            return getHistory(connection, snippetClient);
+        case 'selection_info':
+            return getSelectionInfoHandler(connection, snippetClient);
+        default:
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: unknown inspect target "${String(what)}". Allowed: ${INSPECT_WHATS.join(', ')}.`,
+                    },
+                ],
+                isError: true,
+            };
+    }
+}