editmamei 0.17.4 → 0.18.0

package/dist/tools/adjustment-tools.js

@@ -603,13 +603,32 @@ const shadowsHighlightsSchema = {
         },
     },
 };
+const APPLY_ADJUSTMENT_TYPES = ['shadows_highlights', 'equalize', 'color_lookup'];
+const APPLY_ADJUSTMENT_INPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: [...APPLY_ADJUSTMENT_TYPES],
+            description: 'Which destructive adjustment to bake (none exist as adjustment layers in PS). ' +
+                'shadows_highlights: one-pass shadow/highlight recovery (shadow_amount, highlight_amount, …). ' +
+                'equalize: parameter-free histogram equalization. ' +
+                'color_lookup: bake a 3DLUT grade — cl_lut_name REQUIRED. ' +
+                'All auto-duplicate the active layer by default (apply_to_active_layer:true to bake in place).',
+        },
+        ...shadowsHighlightsSchema.properties,
+        ...equalizeSchema.properties,
+        ...colorLookupBakeSchema.properties,
+    },
+    required: ['type'],
+};
 export function createAdjustmentTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_apply_shadows_highlights',
-                description: "Recover blown highlights and crushed shadows in a single pass. **Photoshop does not ship Shadows/Highlights as an adjustment layer** — it only exists as the destructive Image > Adjustments > Shadows/Highlights command. By default this tool applies it to a DUPLICATE of the active layer (auto-duplicate-first per Bundle O 2026-06-01), so the original is preserved and you can revert by deleting the copy. Pass `apply_to_active_layer: true` to bake into the original. Auto-rasterizes text/smart-object layers in the path that runs the filter. Defaults reproduce Adobe's dialog defaults (35 shadow amount, 0 highlight amount, +20 color correction).",
-                inputSchema: shadowsHighlightsSchema,
+                name: 'photoshop_apply_adjustment',
+                description: "Apply a DESTRUCTIVE tonal adjustment that Photoshop does NOT offer as an adjustment layer — chosen via `type`. Runs on a DUPLICATE of the active layer by default (auto-duplicate-first per Bundle O — the original is preserved; revert by deleting the copy); pass `apply_to_active_layer: true` to bake in place. Auto-rasterizes text/smart-object layers. `shadows_highlights` recovers blown highlights + crushed shadows in one pass (defaults match Adobe's dialog: 35 shadow amount, +20 color correction); `equalize` stretches/flattens the histogram (parameter-free); `color_lookup` bakes a 3DLUT grade (cl_lut_name required — leaf name of a file in Presets/3DLUTs/ or an absolute .cube/.3dl/.look path). For EDITABLE tonal/color work, prefer photoshop_add_adjustment_layer.",
+                inputSchema: APPLY_ADJUSTMENT_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',
                     properties: {
@@ -622,52 +641,6 @@ export function createAdjustmentTools(connection, snippetClient) {
                         highlight_radius: { type: 'number' },
                         color_correction: { type: 'number' },
                         midtone_contrast: { type: 'number' },
-                        target_was_copy: { type: 'boolean' },
-                        target_layer_name: { type: 'string' },
-                        original_layer_name: { type: 'string' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Shadows/Highlights (destructive, auto-duplicates)',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applyShadowsHighlights(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'photoshop_apply_equalize',
-                description: "Equalize the active layer's tonal distribution — stretches the histogram so it covers the full 0-255 range and tries to flatten the distribution. **Photoshop does not ship Equalize as an adjustment layer** — it only exists as the destructive Image > Adjustments > Equalize command. By default this tool applies it to a DUPLICATE of the active layer (auto-duplicate-first per Bundle O), so the original is preserved and you can revert by deleting the copy. Pass `apply_to_active_layer: true` to bake into the original. Auto-rasterizes text/smart-object layers. Parameter-free — the operation IS the action.",
-                inputSchema: equalizeSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        filter: { type: 'string' },
-                        target_was_copy: { type: 'boolean' },
-                        target_layer_name: { type: 'string' },
-                        original_layer_name: { type: 'string' },
-                        context: { type: 'object' },
-                    },
-                },
-                annotations: {
-                    title: 'Equalize (destructive, auto-duplicates)',
-                    destructiveHint: true,
-                    idempotentHint: false,
-                },
-            },
-            handler: async (args) => applyEqualize(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'photoshop_apply_color_lookup',
-                description: 'Apply a 3DLUT preset as a destructive color grade, baked onto a duplicate of the active layer (the original is preserved). Pass cl_lut_name as the leaf name of any LUT in Photoshop\'s Presets/3DLUTs/ folder (e.g. "FallColors.look", "Kodak 5205 Fuji 3510 (by Adobe).cube", "TealOrangePlusContrast.3DL") or an absolute path to a .cube/.3dl/.look file. Use for color grading where you don\'t need the LUT to stay editable. NOTE: the non-destructive `add_adjustment_layer type=color_lookup` form CANNOT load a LUT via scripting (PS requires an internal parsed-profile blob no scripting API generates; see docs/20260603-color-lookup-limitation.md) — this bake form is the only working LUT path. For an editable grade, compose selective_color + color_balance + curves to mimic the look.',
-                inputSchema: colorLookupBakeSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        filter: { type: 'string' },
                         lut_path: { type: 'string' },
                         lut_format: { type: 'string' },
                         target_was_copy: { type: 'boolean' },
@@ -677,12 +650,12 @@ export function createAdjustmentTools(connection, snippetClient) {
                     },
                 },
                 annotations: {
-                    title: 'Apply Color Lookup (destructive, auto-duplicates)',
+                    title: 'Apply Adjustment (destructive, auto-duplicates)',
                     destructiveHint: true,
                     idempotentHint: false,
                 },
             },
-            handler: async (args) => applyColorLookup(connection, snippetClient, args),
+            handler: async (args) => applyAdjustment(connection, snippetClient, args),
         },
         {
             tool: {
@@ -716,6 +689,28 @@ export function createAdjustmentTools(connection, snippetClient) {
         },
     ];
 }
+async function applyAdjustment(connection, snippetClient, rawArgs) {
+    const type = rawArgs.type;
+    const { type: _omit, ...rest } = rawArgs;
+    switch (type) {
+        case 'shadows_highlights':
+            return applyShadowsHighlights(connection, snippetClient, rest);
+        case 'equalize':
+            return applyEqualize(connection, snippetClient, rest);
+        case 'color_lookup':
+            return applyColorLookup(connection, snippetClient, rest);
+        default:
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: unknown adjustment type "${String(type)}". Allowed: ${APPLY_ADJUSTMENT_TYPES.join(', ')}.`,
+                    },
+                ],
+                isError: true,
+            };
+    }
+}
 const FORWARDED_KEYS = new Set([
     'curves_preset',
     'black_point',

package/dist/tools/detection-tools.js

@@ -0,0 +1,209 @@
+import { decode, encode } from 'jpeg-js';
+import { validateArgs } from '../utils/validate.js';
+import { detectActiveDoc } from '../detection/detect-active-doc.js';
+import { OnnxDetectionClient, } from '../detection/detection-client.js';
+const detectSchema = {
+    type: 'object',
+    properties: {
+        target: {
+            type: 'string',
+            enum: ['faces', 'objects', 'both'],
+            default: 'both',
+            description: "What to detect: 'faces' (forward-facing faces), 'objects' (COCO-80 classes: person, dog, car, chair, …), or 'both'.",
+        },
+        max_dimension: {
+            type: 'number',
+            default: 1024,
+            minimum: 256,
+            maximum: 4096,
+            description: 'Long-edge pixels of the JPEG the detectors run on. Smaller is faster; the models downscale internally so 1024 is plenty. Returned coordinates are always in full document pixels regardless.',
+        },
+        face_threshold: {
+            type: 'number',
+            default: 0.7,
+            minimum: 0,
+            maximum: 1,
+            description: 'Minimum face confidence (0–1).',
+        },
+        object_threshold: {
+            type: 'number',
+            default: 0.4,
+            minimum: 0,
+            maximum: 1,
+            description: 'Minimum object confidence (0–1).',
+        },
+        max_objects: {
+            type: 'number',
+            default: 50,
+            minimum: 1,
+            maximum: 300,
+            description: 'Cap on returned objects, highest-confidence first.',
+        },
+        annotate: {
+            type: 'boolean',
+            default: true,
+            description: 'Return an annotated preview with the detected boxes drawn (faces cyan, objects magenta) so you can visually confirm the detections.',
+        },
+    },
+};
+function drawBoxes(bytes, boxes) {
+    const img = decode(bytes, { useTArray: true, formatAsRGBA: true });
+    const { width: w, height: h, data } = img;
+    const thickness = Math.max(2, Math.round(Math.max(w, h) / 400));
+    const setPx = (x, y, r, g, b) => {
+        if (x < 0 || y < 0 || x >= w || y >= h)
+            return;
+        const i = (y * w + x) * 4;
+        data[i] = r;
+        data[i + 1] = g;
+        data[i + 2] = b;
+        data[i + 3] = 255;
+    };
+    for (const { bbox, rgb } of boxes) {
+        const x1 = Math.round(bbox[0]);
+        const y1 = Math.round(bbox[1]);
+        const x2 = Math.round(bbox[2]);
+        const y2 = Math.round(bbox[3]);
+        for (let x = x1; x <= x2; x++)
+            for (let k = 0; k < thickness; k++) {
+                setPx(x, y1 + k, rgb[0], rgb[1], rgb[2]);
+                setPx(x, y2 - k, rgb[0], rgb[1], rgb[2]);
+            }
+        for (let y = y1; y <= y2; y++)
+            for (let k = 0; k < thickness; k++) {
+                setPx(x1 + k, y, rgb[0], rgb[1], rgb[2]);
+                setPx(x2 - k, y, rgb[0], rgb[1], rgb[2]);
+            }
+    }
+    return encode({ data, width: w, height: h }, 88).data;
+}
+function summarizeObjects(objects) {
+    if (!objects || objects.length === 0)
+        return '';
+    const counts = new Map();
+    for (const o of objects)
+        counts.set(o.label, (counts.get(o.label) ?? 0) + 1);
+    return [...counts.entries()].map(([l, n]) => (n > 1 ? `${l}×${n}` : l)).join(', ');
+}
+async function detect(connection, client, rawArgs) {
+    try {
+        const args = validateArgs(detectSchema, rawArgs);
+        const target = args.target ?? 'both';
+        const annotate = args.annotate ?? true;
+        const wantFaces = target === 'faces' || target === 'both';
+        const wantObjects = target === 'objects' || target === 'both';
+        const det = await detectActiveDoc(connection, client, {
+            faces: wantFaces,
+            objects: wantObjects,
+            maxDimension: args.max_dimension,
+            faceThreshold: args.face_threshold,
+            objectThreshold: args.object_threshold,
+            maxObjects: args.max_objects,
+        });
+        const mapped = det.result;
+        const content = [];
+        if (annotate) {
+            try {
+                const boxes = [
+                    ...(det.raw.faces ?? []).map((f) => ({
+                        bbox: f.bbox,
+                        rgb: [0, 220, 255],
+                    })),
+                    ...(det.raw.objects ?? []).map((o) => ({
+                        bbox: o.bbox,
+                        rgb: [255, 0, 220],
+                    })),
+                ];
+                const annotated = drawBoxes(det.exportBytes, boxes);
+                content.push({
+                    type: 'image',
+                    data: annotated.toString('base64'),
+                    mimeType: 'image/jpeg',
+                });
+            }
+            catch {
+            }
+        }
+        const faceCount = mapped.faces?.length ?? 0;
+        const objCount = mapped.objects?.length ?? 0;
+        const parts = [];
+        if (wantFaces)
+            parts.push(`${faceCount} face${faceCount === 1 ? '' : 's'}`);
+        if (wantObjects) {
+            const tally = summarizeObjects(mapped.objects);
+            parts.push(`${objCount} object${objCount === 1 ? '' : 's'}${tally ? ` (${tally})` : ''}`);
+        }
+        content.push({
+            type: 'text',
+            text: `Detected ${parts.join(', ')} in the active document (${det.docWidth}×${det.docHeight}). ` +
+                `All bounding boxes are [x1, y1, x2, y2] in document pixels.`,
+        });
+        return {
+            content,
+            structuredContent: {
+                image: mapped.image,
+                backends: mapped.backends,
+                ...(mapped.faces ? { faces: mapped.faces } : {}),
+                ...(mapped.objects ? { objects: mapped.objects } : {}),
+                context: det.context,
+            },
+        };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: 'text', text: `Error during detection: ${msg}` }],
+            isError: true,
+        };
+    }
+}
+export function createDetectionTools(connection, _snippetClient, client = new OnnxDetectionClient()) {
+    return [
+        {
+            tool: {
+                name: 'photoshop_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: {
+                    type: 'object',
+                    properties: {
+                        image: {
+                            type: 'object',
+                            properties: { width: { type: 'number' }, height: { type: 'number' } },
+                        },
+                        backends: { type: 'object' },
+                        faces: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    bbox: { type: 'array', items: { type: 'number' } },
+                                    confidence: { type: 'number' },
+                                },
+                            },
+                        },
+                        objects: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    label: { type: 'string' },
+                                    class_id: { type: 'number' },
+                                    bbox: { type: 'array', items: { type: 'number' } },
+                                    confidence: { type: 'number' },
+                                },
+                            },
+                        },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Detect Faces & Objects',
+                    readOnlyHint: true,
+                    idempotentHint: true,
+                },
+            },
+            handler: async (args) => detect(connection, client, args),
+        },
+    ];
+}

package/dist/tools/document-tools.js

@@ -132,6 +132,22 @@ const exportPngSchema = {
     },
     required: ['output_path'],
 };
+const EXPORT_FORMATS = ['jpeg', 'png'];
+const exportInputSchema = {
+    type: 'object',
+    properties: {
+        format: {
+            type: 'string',
+            enum: [...EXPORT_FORMATS],
+            description: 'Output image format. jpeg: quality 0-100, optional convert_to_srgb + embed_color_profile. ' +
+                'png: transparent_background (alpha) or flattened-on-white, compression 0-9. ' +
+                'Both take output_path (required) and optional long_edge_px (downscale only).',
+        },
+        ...exportJpegSchema.properties,
+        ...exportPngSchema.properties,
+    },
+    required: ['format', 'output_path'],
+};
 export function createDocumentTools(connection, snippetClient) {
     return [
         {
@@ -232,9 +248,9 @@ export function createDocumentTools(connection, snippetClient) {
         },
         {
             tool: {
-                name: 'photoshop_export_jpeg',
-                description: 'Export the active document as a flattened JPEG. Optionally converts to sRGB and resizes so the long edge equals a target pixel count (downscale only). Operates on a duplicate — working document is unchanged.',
-                inputSchema: exportJpegSchema,
+                name: 'photoshop_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: {
                     type: 'object',
                     properties: {
@@ -244,47 +260,42 @@ export function createDocumentTools(connection, snippetClient) {
                         height_px: { type: 'number' },
                         quality: { type: 'number' },
                         quality_ps_scale: { type: 'number' },
-                        context: { type: 'object' },
-                    },
-                    required: ['success'],
-                },
-                annotations: {
-                    title: 'Export JPEG (pipeline)',
-                    destructiveHint: true,
-                    openWorldHint: true,
-                    idempotentHint: true,
-                },
-            },
-            handler: async (args) => exportJpegPipeline(connection, snippetClient, args),
-        },
-        {
-            tool: {
-                name: 'photoshop_export_png',
-                description: 'Export the active document as a PNG. Choose transparent background (alpha preserved) or flattened onto white. Optionally resizes (downscale only). Operates on a duplicate — working document is unchanged.',
-                inputSchema: exportPngSchema,
-                outputSchema: {
-                    type: 'object',
-                    properties: {
-                        success: { type: 'boolean' },
-                        exported_to: { type: 'string' },
-                        width_px: { type: 'number' },
-                        height_px: { type: 'number' },
                         transparent: { type: 'boolean' },
                         context: { type: 'object' },
                     },
                     required: ['success'],
                 },
                 annotations: {
-                    title: 'Export PNG (pipeline)',
+                    title: 'Export Image (pipeline)',
                     destructiveHint: true,
                     openWorldHint: true,
                     idempotentHint: true,
                 },
             },
-            handler: async (args) => exportPngPipeline(connection, snippetClient, args),
+            handler: async (args) => exportImage(connection, snippetClient, args),
         },
     ];
 }
+async function exportImage(connection, snippetClient, rawArgs) {
+    const format = rawArgs.format;
+    const { format: _omit, ...rest } = rawArgs;
+    switch (format) {
+        case 'jpeg':
+            return exportJpegPipeline(connection, snippetClient, rest);
+        case 'png':
+            return exportPngPipeline(connection, snippetClient, rest);
+        default:
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: unknown export format "${String(format)}". Allowed: ${EXPORT_FORMATS.join(', ')}.`,
+                    },
+                ],
+                isError: true,
+            };
+    }
+}
 async function createDocument(connection, snippetClient, rawArgs) {
     try {
         const args = validateArgs(createDocumentSchema, rawArgs);