editmamei 0.19.0 → 0.22.0

package/dist/tools/shape-tools.js

@@ -0,0 +1,216 @@
+import { runScript } from '../utils/run-script.js';
+import { validateArgs } from '../utils/validate.js';
+import { OnnxLandmarkDetectionClient } from '../detection/landmark-detection-client.js';
+import { resolveExpectedPlacement, PLACEMENT_SCHEMA } from '../perception/grounding-locate.js';
+const SHAPE_TYPES = ['rectangle', 'ellipse', 'line'];
+const rgbColorFragment = {
+    type: 'object',
+    description: 'RGB color 0-255.',
+    properties: {
+        r: { type: 'number', minimum: 0, maximum: 255 },
+        g: { type: 'number', minimum: 0, maximum: 255 },
+        b: { type: 'number', minimum: 0, maximum: 255 },
+    },
+    required: ['r', 'g', 'b'],
+};
+const shapeInputSchema = {
+    type: 'object',
+    properties: {
+        type: {
+            type: 'string',
+            enum: [...SHAPE_TYPES],
+            description: 'rectangle: a box (left/top/right/bottom; corner_radius>0 rounds the corners). ' +
+                'ellipse: an oval in the left/top/right/bottom bounding box. ' +
+                'line: a straight line from (start_x,start_y) to (end_x,end_y) with `weight` thickness.',
+        },
+        placement: {
+            ...PLACEMENT_SCHEMA,
+            description: 'ANCHOR-RELATIONAL placement (preferred over guessing pixels): rectangle/ellipse ← a region relation ' +
+                '(inside/gap) → the resolved region bounding box; line ← a path relation (along/offset-curve over a traced ' +
+                'edge or a Pro face-mesh landmark curve) → a straight line between the resolved curve endpoints. The shape ' +
+                'is created ONLY if the gate PASSES (otherwise an error and no layer). When set, left/top/right/bottom and ' +
+                'start_x/start_y/end_x/end_y are ignored, but styling (fill_color/stroke/weight/corner_radius) still ' +
+                'applies. See ps_resolve_placement for the anchors + relation vocabulary.',
+        },
+        left: {
+            type: 'number',
+            description: 'rectangle/ellipse: bounding-box left edge, document px.',
+        },
+        top: { type: 'number', description: 'rectangle/ellipse: bounding-box top edge, document px.' },
+        right: {
+            type: 'number',
+            description: 'rectangle/ellipse: bounding-box right edge, document px.',
+        },
+        bottom: {
+            type: 'number',
+            description: 'rectangle/ellipse: bounding-box bottom edge, document px.',
+        },
+        corner_radius: {
+            type: 'number',
+            description: 'rectangle only: corner radius in px. 0 (default) = sharp corners; >0 = rounded.',
+            minimum: 0,
+            default: 0,
+        },
+        start_x: { type: 'number', description: 'line: start point X, document px.' },
+        start_y: { type: 'number', description: 'line: start point Y, document px.' },
+        end_x: { type: 'number', description: 'line: end point X, document px.' },
+        end_y: { type: 'number', description: 'line: end point Y, document px.' },
+        weight: {
+            type: 'number',
+            description: 'line only: line thickness in px. Default 4.',
+            minimum: 0.1,
+            default: 4,
+        },
+        fill_color: {
+            ...rgbColorFragment,
+            description: 'Fill color (the line color for type=line). RGB 0-255. Default black.',
+        },
+        stroke_width: {
+            type: 'number',
+            description: 'rectangle/ellipse: outline width in px. 0 (default) = no stroke (fill only). Ignored for line (use weight).',
+            minimum: 0,
+            default: 0,
+        },
+        stroke_color: {
+            ...rgbColorFragment,
+            description: 'rectangle/ellipse stroke color when stroke_width>0. RGB 0-255. Default black.',
+        },
+    },
+    required: ['type'],
+};
+export function createShapeTools(connection, snippetClient, client = new OnnxLandmarkDetectionClient()) {
+    return [
+        {
+            tool: {
+                name: 'ps_shape',
+                description: 'Draw a vector SHAPE layer — `rectangle` (optionally rounded via corner_radius), `ellipse`, or `line` — filled with a solid color, optionally stroked. Aim it EITHER by anchor-relational `placement` (preferred: name anchors + a relation and the resolver computes the geometry, verified by an objective gate — no pixel-guessing; rectangle/ellipse ← a region relation, line ← a path relation) OR by ABSOLUTE document pixels (top-left origin: rectangle/ellipse take left/top/right/bottom; line takes start_x/start_y → end_x/end_y plus weight — you must know the pixel positions, so prefer the anchor-relational `placement` path above and verify the result with a preview). Creates a new vector layer (non-destructive — delete it to remove). (AM-only; verified live on PS 27.2.0.)',
+                inputSchema: shapeInputSchema,
+                outputSchema: {
+                    type: 'object',
+                    properties: {
+                        shape_created: { type: 'boolean' },
+                        shape_type: { type: 'string' },
+                        layer_name: { type: 'string' },
+                        stroked: { type: 'boolean' },
+                        placement: {
+                            type: 'object',
+                            description: 'Present when anchor-relational placement was used: the resolved geometry + gate verdict.',
+                            properties: {
+                                target: { type: 'string' },
+                                gate: { type: 'object' },
+                                anchors: { type: 'object' },
+                                geometry: { type: 'object' },
+                            },
+                        },
+                        context: { type: 'object' },
+                    },
+                },
+                annotations: {
+                    title: 'Shape',
+                    idempotentHint: false,
+                },
+            },
+            handler: async (args) => createShape(connection, snippetClient, client, args),
+        },
+    ];
+}
+function colorParams(color, prefix, params) {
+    const c = color ?? { r: 0, g: 0, b: 0 };
+    params[`${prefix}R`] = c.r ?? 0;
+    params[`${prefix}G`] = c.g ?? 0;
+    params[`${prefix}B`] = c.b ?? 0;
+}
+async function createShape(connection, snippetClient, client, rawArgs) {
+    try {
+        const args = validateArgs(shapeInputSchema, rawArgs);
+        const type = args.type;
+        const params = { shapeType: type };
+        let placementInfo;
+        if (args.placement && type === 'line') {
+            const rp = await resolveExpectedPlacement(connection, client, args.placement, 'path', 'line');
+            const start = rp.curve[0];
+            const end = rp.curve[rp.curve.length - 1];
+            const geometry = { startX: start.x, startY: start.y, endX: end.x, endY: end.y };
+            Object.assign(params, geometry);
+            placementInfo = {
+                target: rp.target,
+                anchors: rp.anchors,
+                geometry,
+                summary: `(${start.x},${start.y})→(${end.x},${end.y})`,
+            };
+        }
+        else if (args.placement) {
+            const rp = await resolveExpectedPlacement(connection, client, args.placement, 'region', type);
+            const geometry = { ...rp.bbox };
+            Object.assign(params, geometry);
+            placementInfo = { target: rp.target, anchors: rp.anchors, geometry, summary: rp.summary };
+        }
+        else if (type === 'rectangle' || type === 'ellipse') {
+            for (const k of ['left', 'top', 'right', 'bottom']) {
+                if (typeof args[k] !== 'number') {
+                    throw new Error(`${type} requires numeric left/top/right/bottom (missing ${k})`);
+                }
+                params[k] = args[k];
+            }
+        }
+        else {
+            const map = {
+                start_x: 'startX',
+                start_y: 'startY',
+                end_x: 'endX',
+                end_y: 'endY',
+            };
+            for (const k of Object.keys(map)) {
+                if (typeof args[k] !== 'number') {
+                    throw new Error(`line requires numeric start_x/start_y/end_x/end_y (missing ${k})`);
+                }
+                params[map[k]] = args[k];
+            }
+        }
+        if (type === 'rectangle')
+            params.cornerRadius = args.corner_radius ?? 0;
+        else if (type === 'ellipse')
+            params.cornerRadius = 0;
+        else
+            params.weight = args.weight ?? 4;
+        colorParams(args.fill_color, 'fill', params);
+        if (type !== 'line') {
+            params.strokeWidth = args.stroke_width ?? 0;
+            colorParams(args.stroke_color, 'stroke', params);
+        }
+        const script = await snippetClient.build('createShape', params);
+        const result = (await runScript(connection, script));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: placementInfo
+                        ? `Created ${type} shape layer "${String(result.layer_name ?? '')}" at ${placementInfo.summary} (placement gate PASS).`
+                        : `Created ${type} shape layer "${String(result.layer_name ?? '')}".`,
+                },
+            ],
+            structuredContent: placementInfo
+                ? {
+                    ...result,
+                    placement: {
+                        target: placementInfo.target,
+                        gate: { pass: true },
+                        anchors: placementInfo.anchors,
+                        geometry: placementInfo.geometry,
+                    },
+                }
+                : result,
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error in ps_shape: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/text-tools.js

@@ -90,7 +90,7 @@ export function createTextTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_set_text',
+                name: 'ps_set_text',
                 description: 'Set an attribute of the currently active text layer — font (family or PostScript name, optionally size), color (RGB), alignment, or text content — selected via `property`. Idempotent. Throws if the active layer is not a text layer. Font names accept either the PostScript name ("ArialMT") or family name ("Arial", resolved to its Regular/first variant); throws clearly if no installed font matches.',
                 inputSchema: SET_TEXT_INPUT_SCHEMA,
                 outputSchema: {

package/dist/tools/transform-canvas-tools.js

@@ -39,8 +39,8 @@ export function createTransformCanvasTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_transform_canvas',
-                description: 'Transform the whole document (canvas + all layers), not a single layer — choose with `op`. `rotate` spins the canvas by degrees (+cw; pass 90/180/-90 for quarter/half turns). `flip` mirrors the canvas horizontal|vertical. For rotating/flipping ONE layer use photoshop_transform_layer instead.',
+                name: 'ps_transform_canvas',
+                description: 'Transform the whole document (canvas + all layers), not a single layer — choose with `op`. `rotate` spins the canvas by degrees (+cw; pass 90/180/-90 for quarter/half turns). `flip` mirrors the canvas horizontal|vertical. For rotating/flipping ONE layer use ps_transform_layer instead.',
                 inputSchema: CANVAS_INPUT_SCHEMA,
                 outputSchema: {
                     type: 'object',

package/dist/tools/vector-mask-tools.js

@@ -1,22 +1,24 @@
 import { runScript } from '../utils/run-script.js';
 import { validateArgs } from '../utils/validate.js';
-const VECTOR_MASK_OPS = ['add', 'delete', 'link', 'unlink'];
-const ADD_SOURCES = ['from_current_path'];
+const VECTOR_MASK_OPS = ['add', 'delete', 'link', 'unlink', 'enable', 'disable'];
+const ADD_SOURCES = ['from_current_path', 'reveal_all', 'hide_all'];
 const vectorMaskInputSchema = {
     type: 'object',
     properties: {
         op: {
             type: 'string',
             enum: [...VECTOR_MASK_OPS],
-            description: 'add: turn the active path into a vector mask on the active layer (needs a path — make one with photoshop_path first). ' +
+            description: 'add: create a vector mask on the active layer — seeded from the active path (source=from_current_path, needs a path from ps_path) or as an empty reveal_all/hide_all mask (no path needed). ' +
                 "delete: remove the active layer's vector mask. " +
                 'link: link the vector mask to the layer (they transform together). ' +
-                'unlink: unlink the vector mask from the layer (transform independently).',
+                'unlink: unlink the vector mask from the layer (transform independently). ' +
+                'disable: turn the vector mask off (the layer renders unmasked) without deleting it. ' +
+                'enable: turn a disabled vector mask back on.',
         },
         source: {
             type: 'string',
             enum: [...ADD_SOURCES],
-            description: "add only: what the vector mask is seeded from. Currently only 'from_current_path' (the active work/saved path) — the main consumer of photoshop_path.",
+            description: "add only: what the vector mask is seeded from. 'from_current_path' = the active work/saved path (needs a path; the main consumer of ps_path). 'reveal_all' = an empty mask that reveals the whole layer. 'hide_all' = an empty mask that hides the whole layer (paint/draw paths to reveal).",
             default: 'from_current_path',
         },
     },
@@ -26,8 +28,8 @@ export function createVectorMaskTools(connection, snippetClient) {
     return [
         {
             tool: {
-                name: 'photoshop_vector_mask',
-                description: 'Attach, remove, or (un)link a layer VECTOR MASK — the path-driven, resolution-independent companion to a pixel layer mask. Ops: `add` (converts the active path into the mask — the typical flow after photoshop_path op=create_from_selection / save), `delete`, `link`, `unlink`. **Reach for this when** you want a crisp vector-edged mask from a path rather than a painted pixel mask. `add` needs an existing path and a non-background layer. (Vector masks are AM-driven; verified live on PS 27.2.0.)',
+                name: 'ps_vector_mask',
+                description: 'Attach, remove, (un)link, or (dis/en)able a layer VECTOR MASK — the path-driven, resolution-independent companion to a pixel layer mask. Ops: `add` (from the active path via source=from_current_path — the typical flow after ps_path op=create_from_selection / save — or an empty source=reveal_all/hide_all mask), `delete`, `link`, `unlink`, `disable` (turn the mask off without deleting it), `enable` (turn it back on). **Reach for this when** you want a crisp vector-edged mask rather than a painted pixel mask. `add` needs a non-background layer (and a path for from_current_path); the other ops need a layer that already has a vector mask. (Vector masks are AM-driven; verified live on PS 27.2.0.)',
                 inputSchema: vectorMaskInputSchema,
                 outputSchema: {
                     type: 'object',
@@ -35,6 +37,7 @@ export function createVectorMaskTools(connection, snippetClient) {
                         vector_mask_added: { type: 'boolean' },
                         vector_mask_deleted: { type: 'boolean' },
                         vector_mask_linked: { type: 'boolean' },
+                        vector_mask_enabled: { type: 'boolean' },
                         source: { type: 'string' },
                         layer_name: { type: 'string' },
                         context: { type: 'object' },
@@ -73,6 +76,14 @@ async function runVectorMaskOp(connection, snippetClient, rawArgs) {
                 snippet = 'setVectorMaskLink';
                 params = { linked: false };
                 break;
+            case 'enable':
+                snippet = 'setVectorMaskEnabled';
+                params = { enabled: true };
+                break;
+            case 'disable':
+                snippet = 'setVectorMaskEnabled';
+                params = { enabled: false };
+                break;
             default:
                 return {
                     content: [{ type: 'text', text: `Unknown vector-mask op: ${String(op)}` }],
@@ -91,7 +102,7 @@ async function runVectorMaskOp(connection, snippetClient, rawArgs) {
             content: [
                 {
                     type: 'text',
-                    text: `Error in photoshop_vector_mask: ${error instanceof Error ? error.message : String(error)}`,
+                    text: `Error in ps_vector_mask: ${error instanceof Error ? error.message : String(error)}`,
                 },
             ],
             isError: true,
@@ -110,6 +121,10 @@ function summarize(op, r) {
             return `Linked the vector mask to the layer${on}.`;
         case 'unlink':
             return `Unlinked the vector mask from the layer${on}.`;
+        case 'enable':
+            return `Enabled the vector mask${on}.`;
+        case 'disable':
+            return `Disabled the vector mask${on}.`;
         default:
             return 'Vector-mask op complete.';
     }

package/dist/utils/log-buffer.js

@@ -0,0 +1,41 @@
+const DEFAULT_CAPACITY = 1000;
+export class LogRingBuffer {
+    buf;
+    capacity;
+    next = 0;
+    full = false;
+    constructor(capacity = DEFAULT_CAPACITY) {
+        this.capacity = Math.max(1, Math.floor(capacity));
+        this.buf = new Array(this.capacity);
+    }
+    push(line) {
+        this.buf[this.next] = line;
+        this.next = (this.next + 1) % this.capacity;
+        if (this.next === 0)
+            this.full = true;
+    }
+    snapshot() {
+        if (!this.full)
+            return this.buf.slice(0, this.next);
+        return [
+            ...this.buf.slice(this.next),
+            ...this.buf.slice(0, this.next),
+        ];
+    }
+    get size() {
+        return this.full ? this.capacity : this.next;
+    }
+    clear() {
+        this.buf.fill(undefined);
+        this.next = 0;
+        this.full = false;
+    }
+}
+export const sharedLogBuffer = new LogRingBuffer();
+export function recordLogLine(line) {
+    try {
+        sharedLogBuffer.push(line);
+    }
+    catch {
+    }
+}

package/dist/utils/logger.js

@@ -1,3 +1,4 @@
+import { recordLogLine } from './log-buffer.js';
 export var LogLevel;
 (function (LogLevel) {
     LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
@@ -58,12 +59,21 @@ export function parseLogLevel(raw, fallback) {
             return fallback;
     }
 }
+function isVerboseEnabled(v) {
+    if (v === undefined)
+        return false;
+    const s = v.trim().toLowerCase();
+    return s === 'true' || s === '1';
+}
 export class Logger {
     context;
     logLevel;
     constructor(context, logLevel = LogLevel.INFO) {
         this.context = context;
-        this.logLevel = parseLogLevel(process.env.LOG_LEVEL, logLevel);
+        const fallback = isVerboseEnabled(process.env.EDITMAMEI_VERBOSE_LOGGING)
+            ? LogLevel.DEBUG
+            : logLevel;
+        this.logLevel = parseLogLevel(process.env.LOG_LEVEL, fallback);
     }
     log(level, message, ...args) {
         if (level < this.logLevel)
@@ -74,6 +84,7 @@ export class Logger {
         const formattedArgs = args.map(serializeLogArg).join(' ');
         const logMessage = `${prefix} ${message} ${formattedArgs}`.trim();
         process.stderr.write(logMessage + '\n');
+        recordLogLine(logMessage);
     }
     debug(message, ...args) {
         this.log(LogLevel.DEBUG, message, ...args);

package/dist/utils/session-log-reader.js

@@ -1,7 +1,8 @@
-import { readFile } from 'node:fs/promises';
+import { readFile, readdir, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { Logger } from './logger.js';
+const SESSION_FILE_SUFFIX = '.ndjson';
 const logger = new Logger('SessionLogReader');
 export async function readSessionLog(sessionId, opts = {}) {
     const dir = opts.dir ?? join(homedir(), '.editmamei', 'sessions');
@@ -36,3 +37,28 @@ export async function readSessionLog(sessionId, opts = {}) {
     }
     return out;
 }
+export async function listRecentSessionIds(limit, opts = {}) {
+    const dir = opts.dir ?? join(homedir(), '.editmamei', 'sessions');
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const files = names.filter((f) => f.endsWith(SESSION_FILE_SUFFIX));
+    const withMtime = await Promise.all(files.map(async (f) => {
+        try {
+            const s = await stat(join(dir, f));
+            return { id: f.slice(0, -SESSION_FILE_SUFFIX.length), mtime: s.mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return withMtime
+        .filter((x) => x !== null)
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, Math.max(0, limit))
+        .map((x) => x.id);
+}

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.19.0';
+export const VERSION = '0.22.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "editmamei",
-  "version": "0.19.0",
+  "version": "0.22.0",
   "description": "Editmamei — Unlock Photoshop with natural-language photo editing (Community Edition)",
   "main": "dist/index.js",
   "type": "module",