editmamei 1.8.0 → 1.9.0

package/dist/tools/gimp-retouch-tools.js

@@ -0,0 +1,238 @@
+import { GimpError } from '../backends/gimp/errors.js';
+import { GIMP_IMAGE_PROP, GIMP_LAYER_ID_PROP, GIMP_LAYER_PROP, pickSchemaDeclaredKeys, runGimpTool, } from './gimp-shared.js';
+export const RETOUCH_MAX_POINTS = 500;
+export const RETOUCH_MAX_SPOTS = 50;
+export const RETOUCH_MAX_BRUSH = 1000;
+export const RETOUCH_MAX_SPOT_RADIUS = 500;
+export const RETOUCH_MAX_STROKE_WORK = 2000000;
+export const RETOUCH_MAX_SPOT_WORK = 200000;
+const METHODS = ['heal', 'clone', 'spot_heal'];
+const TARGETS = ['retouch_layer', 'in_place'];
+const retouchSchema = {
+    type: 'object',
+    properties: {
+        image: GIMP_IMAGE_PROP,
+        layer: {
+            ...GIMP_LAYER_PROP,
+            description: 'Name of the pixel layer to retouch. Defaults to the selected layer, or the topmost layer ' +
+                'if none is selected.',
+        },
+        layer_id: GIMP_LAYER_ID_PROP,
+        method: {
+            type: 'string',
+            enum: METHODS,
+            description: "'heal': paint a stroke that blends the sampled texture into its surroundings (blemishes, " +
+                "dust, scratches). 'clone': paint a stroke that copies the sampled pixels exactly. " +
+                "'spot_heal': round spots, each healed from an automatically chosen nearby source.",
+        },
+        points: {
+            type: 'array',
+            minItems: 1,
+            maxItems: RETOUCH_MAX_POINTS,
+            items: { type: 'array', minItems: 2, maxItems: 2, items: { type: 'number' } },
+            description: 'heal / clone: the stroke as [[x, y], ...] in image pixels (1-500 points), every one ' +
+                'inside the layer.',
+        },
+        source: {
+            type: 'object',
+            properties: { x: { type: 'number' }, y: { type: 'number' } },
+            required: ['x', 'y'],
+            description: 'heal / clone: the image-pixel point to sample for points[0]; the rest of the stroke ' +
+                'samples at the same offset. Give this OR source_offset.',
+        },
+        source_offset: {
+            type: 'object',
+            properties: { dx: { type: 'number' }, dy: { type: 'number' } },
+            required: ['dx', 'dy'],
+            description: 'heal / clone: sample this many pixels from each stroke point (source = point + offset). ' +
+                'Give this OR source.',
+        },
+        brush_size: {
+            type: 'number',
+            minimum: 1,
+            maximum: RETOUCH_MAX_BRUSH,
+            default: 20,
+            description: 'heal / clone: brush diameter in pixels. spot_heal sizes its own brush.',
+        },
+        hardness: {
+            type: 'number',
+            minimum: 0,
+            maximum: 1,
+            description: 'heal / clone: brush edge hardness, 0 soft to 1 hard. Default 0.5 for heal, 0.8 for ' +
+                'clone. Not allowed with spot_heal.',
+        },
+        source_layer_id: {
+            ...GIMP_LAYER_ID_PROP,
+            description: 'clone only: sample from this pixel layer instead of the one being painted. The source ' +
+                'point plus the stroke must lie inside it.',
+        },
+        spots: {
+            type: 'array',
+            minItems: 1,
+            maxItems: RETOUCH_MAX_SPOTS,
+            items: {
+                type: 'object',
+                properties: { x: { type: 'number' }, y: { type: 'number' }, radius: { type: 'number' } },
+                required: ['x', 'y', 'radius'],
+            },
+            description: 'spot_heal: [{x, y, radius}] in image pixels (1-50 spots, radius 1-500). The source for ' +
+                'each is picked from 8 directions at about 2.2x and 3.5x the radius, by how closely its ' +
+                'brightness and texture match the ring around the spot. Every source is chosen before ' +
+                'anything is painted, so a spot with no usable source fails the whole call unchanged.',
+        },
+        target: {
+            type: 'string',
+            enum: TARGETS,
+            default: 'retouch_layer',
+            description: "'retouch_layer': paint on a 'Retouch' copy directly above the layer (made on the first " +
+                'call, reused while it stays directly above the layer it was made from); needs a Normal ' +
+                "mode, 100% opacity layer without a layer mask. 'in_place': paint the layer itself.",
+        },
+    },
+    required: ['image', 'method'],
+};
+const bad = (message) => {
+    throw new GimpError('invalid_argument', message);
+};
+function isNum(v) {
+    return typeof v === 'number' && Number.isFinite(v);
+}
+function checkXY(name, v, keys) {
+    const o = v;
+    if (!o || typeof o !== 'object' || !isNum(o[keys[0]]) || !isNum(o[keys[1]])) {
+        bad(`${name} must be {${keys[0]}, ${keys[1]}} with finite numbers`);
+    }
+}
+export function validateRetouchArgs(args) {
+    const method = args['method'];
+    if (method === 'spot_heal') {
+        const spots = args['spots'];
+        if (!Array.isArray(spots) || spots.length < 1 || spots.length > RETOUCH_MAX_SPOTS) {
+            bad(`spots must be a list of 1..${RETOUCH_MAX_SPOTS} spots for method spot_heal`);
+        }
+        spots.forEach((s, i) => {
+            checkXY(`spots[${i}]`, s, ['x', 'y']);
+            const r = s['radius'];
+            if (!isNum(r) || r < 1 || r > RETOUCH_MAX_SPOT_RADIUS) {
+                bad(`spots[${i}].radius must be within 1..${RETOUCH_MAX_SPOT_RADIUS}`);
+            }
+        });
+        for (const k of ['points', 'source', 'source_offset', 'source_layer_id', 'hardness']) {
+            if (args[k] !== undefined)
+                bad(`${k} does not apply to method spot_heal`);
+        }
+        const spotWork = spots.reduce((a, sp) => a + sp.radius ** 2, 0);
+        if (spotWork > RETOUCH_MAX_SPOT_WORK) {
+            bad('these spots are too large to heal in one call: split them into several calls or use ' +
+                `smaller radii (the sum of radius squared is ${spotWork}, the limit is ${RETOUCH_MAX_SPOT_WORK})`);
+        }
+        return;
+    }
+    const points = args['points'];
+    if (!Array.isArray(points) || points.length < 1 || points.length > RETOUCH_MAX_POINTS) {
+        bad(`points must be a list of 1..${RETOUCH_MAX_POINTS} [x, y] points for method ${String(method)}`);
+    }
+    points.forEach((p, i) => {
+        if (!Array.isArray(p) || p.length !== 2 || !isNum(p[0]) || !isNum(p[1])) {
+            bad(`points[${i}] must be [x, y] with finite numbers`);
+        }
+    });
+    const hasSource = args['source'] !== undefined;
+    const hasOffset = args['source_offset'] !== undefined;
+    if (hasSource === hasOffset)
+        bad('give exactly one of source {x, y} or source_offset {dx, dy}');
+    if (hasSource)
+        checkXY('source', args['source'], ['x', 'y']);
+    else
+        checkXY('source_offset', args['source_offset'], ['dx', 'dy']);
+    if (args['spots'] !== undefined)
+        bad(`spots does not apply to method ${String(method)}`);
+    const brush = args['brush_size'] ?? 20;
+    const pts = points;
+    let length = 0;
+    for (let i = 1; i < pts.length; i++) {
+        length += Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]);
+    }
+    const strokeWork = (length + brush) * brush;
+    if (strokeWork > RETOUCH_MAX_STROKE_WORK) {
+        bad('this stroke is too long for its brush size to paint in one call: split the stroke into ' +
+            'several calls or use a smaller brush ' +
+            `(about ${Math.round(strokeWork)} px of path x brush, the limit is ${RETOUCH_MAX_STROKE_WORK})`);
+    }
+    if (method === 'heal' && args['source_layer_id'] !== undefined) {
+        bad('source_layer_id applies to method clone only');
+    }
+}
+export function createGimpRetouchTools(gimp) {
+    return [
+        {
+            tool: {
+                name: 'gimp_retouch',
+                description: 'Headless GIMP: heal or clone pixels with a round brush. method heal paints a stroke ' +
+                    'that samples texture from elsewhere and blends it into its surroundings, for blemishes, ' +
+                    'dust and scratches; clone paints a stroke that copies the sampled pixels exactly; ' +
+                    "spot_heal takes round spots {x, y, radius} and picks each one's source automatically, " +
+                    'from the nearby area whose brightness and texture best match the ring around the spot. ' +
+                    'Everything is in image pixels. By default (target retouch_layer) the paint lands on a ' +
+                    '"Retouch" copy of the layer directly above it, shown only where you painted, so the ' +
+                    'original and the picture everywhere else stay untouched; later calls reuse that copy ' +
+                    'while it stays directly above the layer it was made from. target in_place paints the ' +
+                    'layer itself, and is required for a layer that is below 100% opacity, not in Normal ' +
+                    'mode, or has a layer mask; a layer with semi-transparent pixels also shows its original ' +
+                    'through the copy, so use in_place there. The current selection is kept and does not clip the ' +
+                    'retouch. Refuses layer groups, text layers, locked or hidden layers, indexed images, ' +
+                    'and any point or spot outside the layer. A call has a work limit (a long stroke with a ' +
+                    'big brush, or many large spots): split it into several calls or use a smaller brush. ' +
+                    'Do NOT use for removing whole objects; a stroke or spot only blends in texture ' +
+                    'at the size of the brush. Returns layer_id, layer_name, created_layer, painted_bbox ' +
+                    "[x, y, w, h] and, for spot_heal, each spot's chosen source offset and score (lower is " +
+                    'a closer match).',
+                inputSchema: retouchSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        layer_id: { type: 'number' },
+                        layer_name: { type: 'string' },
+                        created_layer: { type: 'boolean' },
+                        method: { type: 'string' },
+                        target: { type: 'string' },
+                        painted_bbox: { type: 'array' },
+                        spots: { type: 'array' },
+                        brush_size: { type: 'number' },
+                        hardness: { type: 'number' },
+                    },
+                },
+                annotations: {
+                    title: 'Retouch GIMP Layer',
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    idempotentHint: false,
+                    openWorldHint: true,
+                },
+            },
+            handler: async (args) => runGimpTool({
+                gimp,
+                rawArgs: args,
+                schema: retouchSchema,
+                op: 'retouch',
+                errorPrefix: 'Error retouching GIMP layer',
+                params: (validated) => {
+                    validateRetouchArgs(validated);
+                    return pickSchemaDeclaredKeys(retouchSchema, validated);
+                },
+                successText: (result) => {
+                    const r = result;
+                    const [x, y, w, h] = r.painted_bbox;
+                    const what = r.spots
+                        ? `${r.spots.length} spot(s) healed`
+                        : r.method === 'clone'
+                            ? 'cloned'
+                            : 'healed';
+                    return (`Retouch: ${what} on "${r.layer_name}" (layer ${r.layer_id}` +
+                        `${r.created_layer ? ', new Retouch layer' : ''}), painted area ${w}x${h} at ${x},${y}.`);
+                },
+            }),
+        },
+    ];
+}
+export const RETOUCH_SCHEMA_FOR_TESTS = retouchSchema;

package/dist/tools/gimp-text-tools.js

@@ -1,7 +1,14 @@
 import { validateArgs } from '../utils/validate.js';
 import { toolGimpErrorResult } from '../utils/tool-helpers.js';
 import { GIMP_IMAGE_PROP, GIMP_LAYER_ID_PROP, GIMP_LAYER_PROP, pickSchemaDeclaredKeys, } from './gimp-shared.js';
-const TEXT_OPS = ['create', 'set_content', 'set_font', 'set_color', 'set_alignment'];
+const TEXT_OPS = [
+    'create',
+    'set_content',
+    'set_font',
+    'set_color',
+    'set_alignment',
+    'set_box',
+];
 const ALIGNMENTS = [
     'LEFT',
     'CENTER',
@@ -22,7 +29,8 @@ const textSchema = {
                 '100,100) and `font_size` (default 24), optionally with font_name, red/green/blue and ' +
                 'alignment. set_content: replace the text with `text`. set_font: set `font_name` ' +
                 '(optionally `font_size`). set_color: set red/green/blue. set_alignment: set ' +
-                '`alignment`. The set_* ops act on the text layer named by `layer_id` or `layer`.',
+                '`alignment`. set_box: put the layer in a fixed `box` (re-wrapping its text). The ' +
+                'set_* ops act on the text layer named by `layer_id` or `layer`.',
         },
         layer: {
             ...GIMP_LAYER_PROP,
@@ -85,7 +93,36 @@ const textSchema = {
             type: 'string',
             enum: [...ALIGNMENTS],
             description: 'Text alignment. GIMP supports LEFT, CENTER, RIGHT and FULLYJUSTIFIED; the other ' +
-                'values ps_text accepts (LEFTJUSTIFIED, CENTERJUSTIFIED, RIGHTJUSTIFIED) are refused.',
+                'values ps_text accepts (LEFTJUSTIFIED, CENTERJUSTIFIED, RIGHTJUSTIFIED) are refused. ' +
+                'In a box, alignment applies within the box width.',
+        },
+        box: {
+            type: 'object',
+            properties: {
+                width: { type: 'integer', minimum: 1, maximum: 30000 },
+                height: { type: 'integer', minimum: 1, maximum: 30000 },
+            },
+            required: ['width'],
+            description: 'create, set_box: a fixed text box {width, height?} in image pixels (each side 1 to ' +
+                '30000, area within the text-box cap: 64 MP at 8-bit, 32 MP at 16-bit, 16 MP at 32-bit). The text wraps at `width` (newlines in the ' +
+                'text are kept) and is placed at the top of the box; GIMP has no vertical alignment, so ' +
+                'a taller box leaves the space below. Omit `height` and the layer grows to the wrapped ' +
+                "text's height. The box survives later set_content / set_font / set_alignment edits. " +
+                'Emoji and some scripts depend on installed fonts and may render as empty boxes.',
+        },
+        fit: {
+            type: 'boolean',
+            description: 'create, set_box: with a `box` that has both width and height (at most 16 MP), shrink the ' +
+                'text to approximately the largest size (at most font_size, or the current size for ' +
+                'set_box) at which the wrapped text fits inside the box, searched in at most 12 trial ' +
+                'renders. A word wider than the box counts as not fitting. The result ' +
+                'reports `fitted`: false when even min_size overflows (the text is left at min_size).',
+        },
+        min_size: {
+            type: 'number',
+            minimum: 1,
+            maximum: 10000,
+            description: 'fit only: the smallest font size to try, in pixels (default 8).',
         },
     },
     required: ['image', 'op'],
@@ -103,7 +140,12 @@ async function gimpText(gimp, rawArgs) {
                 {
                     type: 'text',
                     text: `Text layer "${result.name}" (id ${result.layer_id}): ${result.font ?? 'unknown font'} ` +
-                        `${result.font_size} pt${sizing}, ${b.width}x${b.height} px at (${b.x}, ${b.y}).`,
+                        `${result.font_size} pt${sizing}, ${b.width}x${b.height} px at (${b.x}, ${b.y}).` +
+                        (result.fitted === undefined
+                            ? ''
+                            : result.fitted
+                                ? ' Fitted to the box.'
+                                : ' Does NOT fit: even min_size overflows the box, so the text is left at min_size and is clipped.'),
                 },
             ],
             structuredContent: result,
@@ -119,15 +161,19 @@ export function createGimpTextTools(gimp) {
             tool: {
                 name: 'gimp_text',
                 description: 'Headless GIMP: create a live, editable text layer or restyle one, chosen with `op` ' +
-                    '(create, set_content, set_font, set_color, set_alignment) — the same ops and ' +
-                    'parameters as ps_text. create adds a layer at `x`/`y` with `text`, `font_size` in ' +
+                    '(create, set_content, set_font, set_color, set_alignment, set_box) — the same ops and ' +
+                    'parameters as ps_text, plus a fixed `box` with wrapping and `fit`. create adds a layer at `x`/`y` with `text`, `font_size` in ' +
                     'points, and optional font_name, red/green/blue and alignment; it reports layer_id, ' +
                     'name, bounds, the image ppi and the font size in pixels. The set_* ops change the text layer named by `layer_id` or `layer` ' +
                     '(a non-text layer is refused). Fonts accept a family ("Inter") or full name ("Inter ' +
                     'Bold"), case-insensitive; a miss is refused with the closest installed names (list ' +
                     'them with gimp_inspect what=fonts). Text is capped at 2000 characters, and a layer ' +
                     'that would render past the size limit is refused and leaves the document unchanged. ' +
-                    'GIMP supports LEFT, CENTER, RIGHT and FULLYJUSTIFIED alignment only. There is no ' +
+                    'GIMP supports LEFT, CENTER, RIGHT and FULLYJUSTIFIED alignment only. `box` {width, ' +
+                    'height?} (create, set_box) fixes the text box so text wraps at `width`; `fit` ' +
+                    'shrinks the size to approximately the largest size at which the wrapped text fits a box with both sides; the result then ' +
+                    'carries `box` and, for fit, `fitted` and `fit_probes`. Text sits at the top of the ' +
+                    'box (no vertical alignment). There is no ' +
                     'undo in this session: gimp_checkpoint or gimp_save_xcf first when in doubt.',
                 inputSchema: textSchema,
                 outputSchema: {
@@ -164,6 +210,20 @@ export function createGimpTextTools(gimp) {
                                 height: { type: 'number' },
                             },
                         },
+                        box: {
+                            type: 'object',
+                            description: 'create / set_box with a box: the resulting box in pixels.',
+                            properties: { width: { type: 'number' }, height: { type: 'number' } },
+                        },
+                        fitted: {
+                            type: 'boolean',
+                            description: 'fit only: false when even min_size overflows the box.',
+                        },
+                        fit_probes: {
+                            type: 'integer',
+                            description: 'fit only: trial renders used (at most 12).',
+                        },
+                        fit_seconds: { type: 'number', description: 'fit only: time the search took.' },
                     },
                 },
                 annotations: {

package/dist/tools/gimp-verify-tools.js

@@ -5,6 +5,7 @@ import { validateArgs } from '../utils/validate.js';
 import { toolGimpErrorResult, unknownDiscriminator } from '../utils/tool-helpers.js';
 import { Logger } from '../utils/logger.js';
 import { GIMP_IMAGE_PROP, GIMP_REGION_PROP, GIMP_MAX_PX_PROP, pickSchemaDeclaredKeys, readRender, defaultPreviewsAllowed, } from './gimp-shared.js';
+import { regionStatsLines } from './gimp-result-text.js';
 const logger = new Logger('GimpVerifyTools');
 const CHANNELS = ['luminance', 'red', 'green', 'blue'];
 export const HISTOGRAM_BIN_COUNT = 256;
@@ -104,6 +105,13 @@ const histogramSchema = {
                 ' Computed on the proxy when it maps to a big-enough proxy area, else auto-falls back to a ' +
                 'full-resolution crop; exact:true always forces the full-resolution crop.',
         },
+        mask: {
+            type: 'string',
+            description: 'The name of a selection channel: measure only the pixels it selects at ' +
+                '50% or more (a hard cut, no partial credit for soft edges), e.g. the mean lightness or ' +
+                'color of a selected object. Combines with region and exact; pixels in the result is ' +
+                'the number of pixels counted.',
+        },
     },
     required: ['image'],
 };
@@ -121,7 +129,7 @@ async function gimpGetHistogram(gimp, rawArgs) {
             content: [
                 {
                     type: 'text',
-                    text: `Histogram (${result.exact ? 'exact' : 'proxy'}, ${result.pixels.toLocaleString()} px): ${summary}${unmirroredNote}`,
+                    text: `Histogram (${result.exact ? 'exact' : 'proxy'}${result.mask ? `, mask ${result.mask}` : ''}, ${result.pixels.toLocaleString()} px): ${summary}${unmirroredNote}`,
                 },
             ],
             structuredContent: result,
@@ -185,7 +193,8 @@ async function gimpCompare(gimp, rawArgs, previewsAllowedFn) {
                 content: [
                     {
                         type: 'text',
-                        text: 'Compared region_a vs region_b (full-resolution, exact).',
+                        text: 'Compared region_a (A) vs region_b (B), full-resolution, exact. Values 0-255.\n' +
+                            regionStatsLines(result.region_a, result.region_b).join('\n'),
                     },
                 ],
                 structuredContent: result,

package/dist/utils/operation-timeouts.js

@@ -4,6 +4,8 @@ export const DEFAULT_SCRIPT_TIMEOUT_MS = 30_000;
 export const SCRIPT_TIMEOUT_FLOOR_MS = 5_000;
 export const OPEN_DOCUMENT_TIMEOUT_MS = 120_000;
 export const OPEN_DOCUMENT_REPROBE_TIMEOUT_MS = 10_000;
+export const SAVE_PSD_TIMEOUT_MS = 120_000;
+export const SAVE_PSD_REPROBE_TIMEOUT_MS = 30_000;
 export const CAMERA_RAW_FILTER_TIMEOUT_MS = 120_000;
 export const SELECT_SUBJECT_TIMEOUT_MS = 120_000;
 export const SELECT_SKY_TIMEOUT_MS = 120_000;
@@ -17,12 +19,12 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     ps_select_subject: SELECT_SUBJECT_TIMEOUT_MS,
     ps_select_sky: SELECT_SKY_TIMEOUT_MS,
     ps_replace_sky: SKY_REPLACEMENT_TIMEOUT_MS,
+    ps_save_psd: SAVE_PSD_TIMEOUT_MS,
     ps_ping: 30_000,
     ps_read_scene: 164_000,
     ps_selection_channel: 123_000,
     ps_select: 54_000,
     ps_modify_selection: 37_000,
-    ps_save_psd: 32_000,
     ps_filter: 31_000,
     ps_get_histogram: 25_000,
     ps_create_document: 20_000,
@@ -101,8 +103,10 @@ export const TOOL_TIMEOUT_BUDGETS_MS = {
     gimp_modify_selection: 90_000,
     gimp_layer_mask: 15_000,
     gimp_get_selection_preview: 30_000,
-    gimp_transform_layer: 30_000,
+    gimp_transform_layer: 90_000,
     gimp_match_layer: 70_000,
+    gimp_retouch: 240_000,
+    gimp_fill: 60_000,
 };
 export const TOOLS_WITHOUT_A_BUDGET = {
     ps_report_problem: 'n=3 measured calls',

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.8.0';
+export const VERSION = '1.9.0';

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "editmamei",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "Photoshop MCP server: natural-language AI photo editing in desktop Photoshop (Community Edition)",
   "mcpName": "io.github.editmamei/editmamei",
   "editmamei": {
     "fixesByVersion": {
+      "1.9.0": [
+        "ps_save_psd"
+      ],
       "1.4.0": [
         "ps_read_scene",
         "ps_selection_channel",
         "ps_select",
         "ps_modify_selection"
       ],
-      "1.1.0": [
-        "ps_create_clipping_mask"
-      ],
       "1.2.0": [
         "ps_delete_layer",
         "ps_select_layer"