editmamei 1.5.1 → 1.6.0

package/README.md

@@ -75,7 +75,7 @@ These are the choices that shape the surface, and the reason an AI assistant can
 
 ## Tool surface
 
-**83 tools across 16 capability groups** (62 Community, 21 Pro). Every tool is namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license.
+**103 tools total.** The Photoshop surface is **87 tools across 16 capability groups** (62 Community, 25 Pro), every one namespaced `ps_*` and discoverable at runtime via `tools/list`. Community tools ship in both editions; Pro tools unlock with a license. Alongside it, a second, independent editor surface drives headless GIMP: **16 `gimp_*` tools, Community, currently in beta**, see [GIMP (beta)](#gimp-beta) below. Pro's additions are Photoshop-only; GIMP has no Pro tier.
 
 | Group | Edition | Tools |
 | --- | --- | --- |
@@ -101,15 +101,29 @@ These are the choices that shape the surface, and the reason an AI assistant can
 | **Templates** | Pro | `template_create_evidence` · `template_save` · `template_list` · `template_apply` · `template_verify` · `template_recall` · `template_delete` |
 | **Automation** | Pro | `list_actions` · `play_action` · `execute_script` · `batch` |
 
+**GIMP (beta), a separate namespace, all Community:**
+
+| Group | Edition | Tools |
+| --- | --- | --- |
+| **GIMP** | Community (beta) | `gimp_ping` · `gimp_overview` · `gimp_open_document` · `gimp_close_document` · `gimp_save_xcf` · `gimp_export` · `gimp_inspect` · `gimp_add_adjustment` · `gimp_filter` · `gimp_crop_document` · `gimp_resize_image` · `gimp_transform_canvas` · `gimp_create_mask` · `gimp_get_preview` · `gimp_get_histogram` · `gimp_compare` |
+
 ## Editions
 
 - **Community** is free and covers the everyday editing surface: documents, layers, selections (including AI Select Subject and Select Sky), non-destructive adjustments, filters, masks, type, retouching, on-device perception, and the inspect/verify primitives.
 - **Pro** adds Camera Raw develop, the grounded precision tools (warp, named-object masks, precision placement), subject-instance targeting, face-mesh perception, the reproducible-template system, and Photoshop Actions plus the scripting escape hatch.
 
+Pro is a Photoshop-only upgrade: it adds nothing to the GIMP surface below.
+
 The split is detailed in [pro-features.md](docs/pro-features.md). Pricing is at [editmamei.com](https://editmamei.com).
 
 This repository holds the Community source. Pro is a separately licensed module and its source is not published here; Community never imports it, so this tree builds and runs on its own.
 
+## GIMP (beta)
+
+Editmamei can also drive GIMP, headless, as a second editor alongside (or instead of) Photoshop. When GIMP 3.2+ is detected on your machine, a `gimp_*` tool set registers next to the `ps_*` one; use it when you ask for GIMP, or when Photoshop isn't available. There's no visible window: edits happen in a background `gimp-console` process, and you follow along through rendered previews in the conversation instead of watching a window change.
+
+The beta covers documents (open, save `.xcf`, export), 13 non-destructive adjustment types, geometric masks, crop/resize/rotate/flip, and the same preview/histogram/compare verification primitives the Photoshop side has. It doesn't yet cover heal/clone, AI subject or sky selection, text, or undo for geometry changes. Full details, requirements, and troubleshooting: [docs/gimp.md](docs/gimp.md).
+
 ## Build from source
 
 ```bash
@@ -151,6 +165,7 @@ The source in this repository is the same code published to npm, so none of the
 - **Getting started:** [docs/getting-started.md](docs/getting-started.md)
 - **FAQ:** [docs/faq.md](docs/faq.md)
 - **Troubleshooting:** [docs/troubleshooting.md](docs/troubleshooting.md)
+- **GIMP (beta):** [docs/gimp.md](docs/gimp.md)
 - **Pro features:** [docs/pro-features.md](docs/pro-features.md)
 - **Roadmap:** [docs/roadmap.md](docs/roadmap.md)
 - **Bugs and feature requests:** [the issue tracker](https://github.com/editmamei/editmamei/issues). If something's broken, ask your assistant to "report a problem" (or run `editmamei report`) to drop an anonymized diagnostic bundle in your Downloads folder, then attach it to the issue.

package/dist/backends/detect-editors.js

@@ -0,0 +1,79 @@
+import { detectGimp } from './gimp/detect.js';
+import { applyEditorEnvOverride } from '../core/settings.js';
+import { TOOL_TIERS, isToolAllowedInEdition } from '../core/tool-tiers.js';
+import { EDITION } from '../edition.js';
+import { Logger } from '../utils/logger.js';
+const logger = new Logger('DetectEditors');
+function anyGimpToolAllowedInEdition(edition) {
+    return Object.keys(TOOL_TIERS).some((name) => name.startsWith('gimp_') && isToolAllowedInEdition(name, edition));
+}
+export async function detectEditors(opts = {}) {
+    const budgetMs = opts.budgetMs ?? 750;
+    const gimpDetector = opts.detectGimp ?? detectGimp;
+    let gimp = null;
+    const gimpProbe = gimpDetector().then((install) => {
+        gimp = install;
+    }, () => {
+        gimp = null;
+    });
+    let timer;
+    const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), budgetMs);
+    });
+    const winner = await Promise.race([gimpProbe.then(() => 'settled'), timeout]);
+    clearTimeout(timer);
+    return { gimp, timedOut: winner === 'timeout' };
+}
+export function resolveEditorRegistration(detected, pin = 'auto', gimpToolsAllowed = true) {
+    if (pin === 'gimp') {
+        if (!gimpToolsAllowed) {
+            logger.warn("editor pinned to 'gimp', but no gimp_* tool ships in this build — falling back to " +
+                'registering ps_* instead of leaving the tool surface almost empty.');
+            return {
+                registerPhotoshop: true,
+                registerGimp: false,
+                gimpInstall: null,
+                gimpDetectionTimedOut: false,
+            };
+        }
+        return {
+            registerPhotoshop: false,
+            registerGimp: true,
+            gimpInstall: detected.gimp,
+            gimpDetectionTimedOut: detected.timedOut,
+        };
+    }
+    if (pin === 'photoshop') {
+        return {
+            registerPhotoshop: true,
+            registerGimp: false,
+            gimpInstall: null,
+            gimpDetectionTimedOut: false,
+        };
+    }
+    const gimpFound = detected.gimp !== null;
+    return {
+        registerPhotoshop: true,
+        registerGimp: gimpFound,
+        gimpInstall: gimpFound ? detected.gimp : null,
+        gimpDetectionTimedOut: false,
+    };
+}
+export async function resolveBootEditors(opts) {
+    const env = opts.env ?? process.env;
+    const effectiveSettings = applyEditorEnvOverride(opts.settings, env);
+    const envGimpPath = env.EDITMAMEI_GIMP_PATH;
+    const gimpPathOverride = envGimpPath && envGimpPath.length > 0
+        ? envGimpPath
+        : (effectiveSettings.gimp_path ?? undefined);
+    const detectGimpOverride = gimpPathOverride
+        ? (o) => detectGimp({ ...o, env: { ...(o?.env ?? env), EDITMAMEI_GIMP_PATH: gimpPathOverride } })
+        : undefined;
+    const detectEditorsFn = opts.detectEditorsFn ?? detectEditors;
+    const gimpToolsAllowed = anyGimpToolAllowedInEdition(EDITION);
+    const detected = gimpToolsAllowed
+        ? await detectEditorsFn({ detectGimp: detectGimpOverride })
+        : { gimp: null, timedOut: false };
+    const decision = resolveEditorRegistration(detected, effectiveSettings.editor, gimpToolsAllowed);
+    return gimpPathOverride ? { ...decision, gimpPathOverride } : decision;
+}

package/dist/backends/gimp/backend.js

@@ -0,0 +1,96 @@
+import { GimpSession } from './session.js';
+import { detectGimp } from './detect.js';
+import { GimpError } from './errors.js';
+import { currentToolBudget } from '../../utils/tool-budget-context.js';
+export class GimpBackend {
+    installInfo;
+    sessionFactory;
+    sessionOptions;
+    detectGimpFn;
+    redetectPending;
+    session;
+    closed = false;
+    constructor(install, opts = {}) {
+        this.installInfo = install;
+        this.sessionFactory = opts.sessionFactory ?? ((o) => new GimpSession(o));
+        this.sessionOptions = opts.sessionOptions ?? {};
+        const gimpPath = opts.gimpPath;
+        this.detectGimpFn =
+            opts.detectGimpFn ??
+                (gimpPath
+                    ? () => detectGimp({ env: { ...process.env, EDITMAMEI_GIMP_PATH: gimpPath } })
+                    : () => detectGimp());
+        this.redetectPending = opts.gimpDetectionTimedOut === true && install === null;
+    }
+    get installed() {
+        return this.installInfo !== null;
+    }
+    get install() {
+        return this.installInfo;
+    }
+    get gimpVersion() {
+        return this.session?.gimpVersion;
+    }
+    get state() {
+        return this.session?.state ?? 'idle';
+    }
+    get startOrigin() {
+        return this.session?.lastStartOrigin;
+    }
+    ensureSession() {
+        if (this.closed) {
+            throw new GimpError('gimp_session_restarted', 'session closed');
+        }
+        if (!this.installInfo) {
+            throw new GimpError('gimp_not_installed', 'no GIMP install was found on this machine. Install GIMP 3.2 or newer, or point at a ' +
+                'gimp-console binary with the EDITMAMEI_GIMP_PATH environment variable, or by running ' +
+                '`editmamei config set gimp_path <path>` (the gimp_path key in settings.json).');
+        }
+        if (!this.session) {
+            this.session = this.sessionFactory({ install: this.installInfo, ...this.sessionOptions });
+        }
+        return this.session;
+    }
+    async maybeRedetect() {
+        if (!this.redetectPending)
+            return;
+        this.redetectPending = false;
+        if (this.installInfo !== null)
+            return;
+        const found = await this.detectGimpFn();
+        if (found)
+            this.installInfo = found;
+    }
+    async call(op, args = {}, timeoutMs) {
+        await this.maybeRedetect();
+        let effectiveTimeoutMs = timeoutMs;
+        if (effectiveTimeoutMs === undefined) {
+            const budget = currentToolBudget();
+            if (budget) {
+                const remaining = budget.deadline - Date.now();
+                if (remaining <= 0) {
+                    throw new GimpError('gimp_timeout', `Tool '${budget.toolName}' exceeded its ${budget.budgetMs}ms budget before ${op} could run.`);
+                }
+                effectiveTimeoutMs = remaining;
+            }
+        }
+        return this.ensureSession().call(op, args, { timeoutMs: effectiveTimeoutMs });
+    }
+    async prepare() {
+        await this.maybeRedetect();
+    }
+    latestPreviewPath() {
+        return this.ensureSession().latestPreviewPath();
+    }
+    copyToLatestPreview(src) {
+        this.ensureSession().copyToLatestPreview(src);
+    }
+    tempPath(name) {
+        return this.ensureSession().tempPath(name);
+    }
+    async shutdown() {
+        this.closed = true;
+        if (this.session)
+            await this.session.shutdown();
+    }
+}