editmamei 0.19.0 → 0.22.0

package/dist/tools/channel-compose-tools.js

@@ -0,0 +1,241 @@
+import { runScript } from '../utils/run-script.js';
+import { validateArgs } from '../utils/validate.js';
+const BLEND_MODES = [
+    'normal',
+    'multiply',
+    'screen',
+    'overlay',
+    'darken',
+    'lighten',
+    'soft_light',
+    'hard_light',
+    'difference',
+    'exclusion',
+    'subtract',
+    'add',
+];
+const blendFragment = {
+    type: 'string',
+    enum: [...BLEND_MODES],
+    description: 'Calculation blend mode: how the source combines with the target. multiply (darken/texture), screen (lighten), overlay/soft_light/hard_light (contrast), difference/exclusion/subtract/add (channel math for masks).',
+};
+const applyImageSchema = {
+    type: 'object',
+    properties: {
+        source_layer: {
+            type: 'string',
+            description: "Which layer to pull the source from: 'merged' (the flattened composite, default) or an exact layer name.",
+            default: 'merged',
+        },
+        source_channel: {
+            type: 'string',
+            enum: ['rgb', 'red', 'green', 'blue', 'alpha'],
+            description: "Source channel: 'rgb' (the composite, default), a single 'red'/'green'/'blue' channel, or 'alpha' (then set source_alpha_name).",
+            default: 'rgb',
+        },
+        source_alpha_name: {
+            type: 'string',
+            description: "Required when source_channel='alpha': the name of the alpha channel to read.",
+        },
+        blend: blendFragment,
+        opacity: {
+            type: 'integer',
+            description: 'Blend opacity 0-100. Default 100 (full strength).',
+            minimum: 0,
+            maximum: 100,
+            default: 100,
+        },
+        apply_to_active_layer: {
+            type: 'boolean',
+            description: 'If false (default) the composite is baked onto a DUPLICATE of the active layer (original preserved — delete the copy to revert). Set true to bake destructively in place.',
+            default: false,
+        },
+    },
+    required: ['blend'],
+};
+const calculationsSchema = {
+    type: 'object',
+    properties: {
+        source1_layer: {
+            type: 'string',
+            description: "Source 1 layer: 'merged' (default) or an exact layer name.",
+            default: 'merged',
+        },
+        source1_channel: {
+            type: 'string',
+            enum: ['red', 'green', 'blue', 'alpha'],
+            description: "Source 1 channel: a single 'red'/'green'/'blue' channel, or 'alpha' (+ name).",
+            default: 'red',
+        },
+        source1_alpha_name: {
+            type: 'string',
+            description: "Required when source1_channel='alpha'.",
+        },
+        source2_layer: {
+            type: 'string',
+            description: "Source 2 layer: 'merged' (default) or an exact layer name.",
+            default: 'merged',
+        },
+        source2_channel: {
+            type: 'string',
+            enum: ['red', 'green', 'blue', 'alpha'],
+            description: "Source 2 channel: a single 'red'/'green'/'blue' channel, or 'alpha' (+ name).",
+            default: 'red',
+        },
+        source2_alpha_name: {
+            type: 'string',
+            description: "Required when source2_channel='alpha'.",
+        },
+        blend: blendFragment,
+        opacity: {
+            type: 'integer',
+            description: 'Blend opacity 0-100. Default 100.',
+            minimum: 0,
+            maximum: 100,
+            default: 100,
+        },
+    },
+    required: ['blend'],
+};
+export function createChannelComposeTools(connection, snippetClient) {
+    return [
+        {
+            tool: {
+                name: 'ps_apply_image',
+                description: 'Composite a source layer + channel onto the ACTIVE layer using a calculation blend mode (Image ▸ Apply Image). **Reach for this** for luminosity blends, frequency-separation re-blends, texture overlays, or pulling one channel into another. Source = a layer (merged or named) and a channel (rgb/red/green/blue/alpha). Bakes into pixels, so by default it runs on a DUPLICATE of the active layer (set apply_to_active_layer=true to bake in place). The active layer must be a normal pixel layer. (AM-only; verified live on PS 27.2.0.)',
+                inputSchema: applyImageSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        applied: { type: 'boolean' },
+                        source_channel: { type: 'string' },
+                        source_layer: { type: 'string' },
+                        blend: { type: 'string' },
+                        opacity: { type: 'number' },
+                        target_was_copy: { type: 'boolean' },
+                        target_layer_name: { type: 'string' },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Apply Image',
+                    destructiveHint: true,
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => applyImage(connection, snippetClient, args),
+        },
+        {
+            tool: {
+                name: 'ps_calculations',
+                description: 'Blend TWO sources (each a layer + single channel) into a NEW alpha channel via a calculation blend mode (Image ▸ Calculations). **Reach for this** to build advanced selections/masks from channel math — e.g. difference of two channels to isolate edges, or multiply two channels for a luminosity mask. Non-destructive: adds a new channel (delete it to revert); the result is loadable as a selection via ps_selection_channel op=load. (AM-only; verified live on PS 27.2.0.)',
+                inputSchema: calculationsSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        calculated: { type: 'boolean' },
+                        new_channel_name: { type: 'string' },
+                        channel_count: { type: 'number' },
+                        blend: { type: 'string' },
+                        opacity: { type: 'number' },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Calculations',
+                    destructiveHint: false,
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => calculations(connection, snippetClient, args),
+        },
+    ];
+}
+async function applyImage(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(applyImageSchema, rawArgs);
+        const params = {
+            sourceLayer: args.source_layer ?? 'merged',
+            sourceChannel: args.source_channel ?? 'rgb',
+            blend: args.blend,
+            opacity: args.opacity ?? 100,
+            applyToActiveLayer: args.apply_to_active_layer ?? false,
+        };
+        if (args.source_alpha_name !== undefined)
+            params.sourceAlphaName = args.source_alpha_name;
+        if (params.sourceChannel === 'alpha' && !params.sourceAlphaName) {
+            throw new Error("source_channel='alpha' requires source_alpha_name");
+        }
+        const script = await snippetClient.build('applyImage', params);
+        const result = (await runScript(connection, script));
+        result.source_channel =
+            params.sourceChannel === 'alpha' ? params.sourceAlphaName : params.sourceChannel;
+        result.blend = params.blend;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Apply Image: ${String(result.source_channel ?? '')} of "${String(result.source_layer ?? '')}" (${String(result.blend ?? '')} @ ${String(result.opacity ?? '')}%) onto "${String(result.target_layer_name ?? '')}".`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error in ps_apply_image: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+async function calculations(connection, snippetClient, rawArgs) {
+    try {
+        const args = validateArgs(calculationsSchema, rawArgs);
+        const params = {
+            source1Layer: args.source1_layer ?? 'merged',
+            source1Channel: args.source1_channel ?? 'red',
+            source2Layer: args.source2_layer ?? 'merged',
+            source2Channel: args.source2_channel ?? 'red',
+            blend: args.blend,
+            opacity: args.opacity ?? 100,
+        };
+        if (args.source1_alpha_name !== undefined)
+            params.source1AlphaName = args.source1_alpha_name;
+        if (args.source2_alpha_name !== undefined)
+            params.source2AlphaName = args.source2_alpha_name;
+        if (params.source1Channel === 'alpha' && !params.source1AlphaName) {
+            throw new Error("source1_channel='alpha' requires source1_alpha_name");
+        }
+        if (params.source2Channel === 'alpha' && !params.source2AlphaName) {
+            throw new Error("source2_channel='alpha' requires source2_alpha_name");
+        }
+        const script = await snippetClient.build('calculations', params);
+        const result = (await runScript(connection, script));
+        result.blend = params.blend;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Calculations → new channel "${String(result.new_channel_name ?? '')}" (${String(result.blend ?? '')} @ ${String(result.opacity ?? '')}%).`,
+                },
+            ],
+            structuredContent: result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error in ps_calculations: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/detection-tools.js

@@ -161,7 +161,7 @@ export function createDetectionTools(connection, _snippetClient, client = new On
     return [
         {
             tool: {
-                name: 'photoshop_detect',
+                name: 'ps_detect',
                 description: 'Locate faces and/or COCO-80 objects (person, dog, car, chair, sofa, …) in the active document using LOCAL on-device computer vision — the image is never sent anywhere. Returns labeled bounding boxes in DOCUMENT-pixel space plus an annotated preview for visual confirmation. Use this to gain semantic scene awareness ("there are 2 people and a dog") and real coordinates before any spatially-targeted edit — far more reliable than estimating positions from a preview. `target` selects faces / objects / both. Read-only: renders a throwaway duplicate, never modifies the working document. Boxes are [x1, y1, x2, y2]. Validate surprising results against the annotated image before acting on them.',
                 inputSchema: detectSchema,
                 outputSchema: {

package/dist/tools/diagnostics-tools.js

@@ -0,0 +1,66 @@
+import { collectDiagnostics, writeDiagnosticBundle, ISSUES_URL } from '../diagnostics/collect.js';
+const reportSchema = {
+    type: 'object',
+    properties: {
+        note: {
+            type: 'string',
+            description: 'Optional short description of the problem (what went wrong, what you were doing). Embedded verbatim after sanitization. No file contents or paths needed.',
+        },
+    },
+};
+export function createDiagnosticsTools(_connection, _snippetClient, deps = {}) {
+    const collect = deps.collect ?? collectDiagnostics;
+    const writeBundle = deps.write ?? writeDiagnosticBundle;
+    return [
+        {
+            tool: {
+                name: 'ps_report_problem',
+                description: "Collect an ANONYMIZED diagnostic bundle and write it to the user's Downloads folder so they can attach it to a bug report — use when Editmamei misbehaves (won't connect, a tool keeps failing, unexpected results). The bundle holds recent server logs, system info (Editmamei/OS/Photoshop versions), and a content-free summary of recent tool calls (name, success, duration, error class). It contains NO image content, NO tool arguments, and file paths reduced to basenames. Does not touch Photoshop; writes one JSON file. After calling, tell the user the file path and that they can attach it to a new issue at " +
+                    ISSUES_URL +
+                    '.',
+                inputSchema: reportSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string' },
+                        bytes: { type: 'number' },
+                        server_log_lines: { type: 'number' },
+                        recent_session_count: { type: 'number' },
+                        desktop_log_included: { type: 'boolean' },
+                        issues_url: { type: 'string' },
+                    },
+                },
+                annotations: {
+                    title: 'Report a problem',
+                    readOnlyHint: false,
+                    destructiveHint: false,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => {
+                const note = typeof args.note === 'string' ? args.note : undefined;
+                const bundle = await collect({ note });
+                const { path, bytes } = await writeBundle(bundle);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Wrote an anonymized diagnostic bundle to:\n  ${path}\n\n` +
+                                `It contains recent logs + system info — no images, no full file paths, no tool arguments. ` +
+                                `Attach this file to a new issue at ${ISSUES_URL} so the maintainers can debug.`,
+                        },
+                    ],
+                    structuredContent: {
+                        path,
+                        bytes,
+                        server_log_lines: bundle.server_log.length,
+                        recent_session_count: bundle.recent_sessions.length,
+                        desktop_log_included: bundle.desktop_log.length > 0,
+                        issues_url: ISSUES_URL,
+                    },
+                };
+            },
+        },
+    ];
+}

package/dist/tools/document-tools.js

@@ -152,8 +152,8 @@ export function createDocumentTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_create_document',
-                description: 'Create a new empty Photoshop document with given dimensions, resolution, and color mode. Returns the new document id and name plus active context. Use this when starting from scratch; prefer photoshop_open_document to load an existing file.',
+                name: 'ps_create_document',
+                description: 'Create a new empty Photoshop document with given dimensions, resolution, and color mode. Returns the new document id and name plus active context. Use this when starting from scratch; prefer ps_open_document to load an existing file.',
                 inputSchema: createDocumentSchema,
                 outputSchema: {
                     type: 'object',
@@ -172,7 +172,7 @@ export function createDocumentTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_close_document',
+                name: 'ps_close_document',
                 description: 'Close the active Photoshop document. Destructive if save=false and the document has unsaved changes. Returns the closed document name plus a fresh context block (which document, if any, is active afterwards).',
                 inputSchema: closeDocumentSchema,
                 outputSchema: {
@@ -194,7 +194,7 @@ export function createDocumentTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_open_document',
+                name: 'ps_open_document',
                 description: 'Open a file from disk into Photoshop with all dialogs suppressed (uses last-used Camera Raw settings for raw/HEIC). Returns document name, dimensions, color mode, and whether the source was a raw format. Use this in the pipeline to load Inbox files for editing.',
                 inputSchema: openDocumentSchema,
                 outputSchema: {
@@ -223,7 +223,7 @@ export function createDocumentTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_save_psd',
+                name: 'ps_save_psd',
                 description: 'Save the active document as a layered PSD to the given path. Saves as a copy, so the working document is unmodified and unrenamed. Use this in the pipeline to land an editable PSD into the Edit folder.',
                 inputSchema: savePsdSchema,
                 outputSchema: {
@@ -248,7 +248,7 @@ export function createDocumentTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_export',
+                name: 'ps_export',
                 description: 'Export the active document to a flattened image file — JPEG or PNG, chosen via `format`. Operates on a duplicate, so the working document is unchanged. Optionally downscales so the long edge equals long_edge_px. JPEG: quality 0-100 (Save-As scale), optional sRGB convert + profile embed. PNG: transparent background (alpha preserved) or flattened onto white, compression 0-9.',
                 inputSchema: exportInputSchema,
                 outputSchema: {