mcp-relight-harmonize 1.0.0

package/dist/server.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = createServer;
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const analyze_optical_1 = require("./tools/analyze_optical");
+const generate_relight_1 = require("./tools/generate_relight");
+const harmonize_1 = require("./tools/harmonize");
+const synthesize_prompt_1 = require("./tools/synthesize_prompt");
+const presets_1 = require("./resources/presets");
+function createServer() {
+    const server = new index_js_1.Server({
+        name: "mcp-relight-harmonize",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+            resources: {},
+        },
+    });
+    // List Tools Handler
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "analyze_optical_profile",
+                    description: "Extract physical optical metrics from an image: Correlated Color Temperature (CCT in Kelvin), " +
+                        "dominant light vectors, azimuth & elevation angles, luminance dynamic range, and surface roughness.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            image_path: {
+                                type: "string",
+                                description: "Absolute or workspace-relative path to the image file.",
+                            },
+                        },
+                        required: ["image_path"],
+                    },
+                },
+                {
+                    name: "generate_relight_variations",
+                    description: "Generate 4 physically-grounded relit image variations (Ambient fill, Dramatic chiaroscuro, " +
+                        "Rim light halo, Mood golden-hour) and save them to the output cache directory.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            image_path: {
+                                type: "string",
+                                description: "Path to the source image.",
+                            },
+                            target_lighting: {
+                                type: "string",
+                                enum: ["Ambient", "Dramatic", "Rim", "Mood", "All"],
+                                default: "All",
+                                description: "Lighting preset: 'Ambient', 'Dramatic', 'Rim', 'Mood', or 'All'.",
+                            },
+                            output_dir: {
+                                type: "string",
+                                description: "Custom output directory. If omitted, uses default cache directory.",
+                            },
+                        },
+                        required: ["image_path"],
+                    },
+                },
+                {
+                    name: "harmonize_composite",
+                    description: "Harmonize and composite a foreground element onto a background scene. Applies Reinhard color " +
+                        "statistics transfer, matches background color temperature, and synthesizes grounded contact shadows.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            foreground_path: {
+                                type: "string",
+                                description: "Path to the foreground subject cutout (PNG/JPG).",
+                            },
+                            background_path: {
+                                type: "string",
+                                description: "Path to the background environment image.",
+                            },
+                            blend_mode: {
+                                type: "string",
+                                enum: ["seamless", "alpha"],
+                                default: "seamless",
+                                description: "Blending algorithm ('seamless' or 'alpha').",
+                            },
+                        },
+                        required: ["foreground_path", "background_path"],
+                    },
+                },
+                {
+                    name: "synthesize_diffusion_prompt",
+                    description: "Synthesize precision enhancement and relighting diffusion prompts for GPT Image (DALL-E 3 / GPT-4o) " +
+                        "and Nano Banana based on physical optical analysis of an image. Includes exact Kelvin temperature, " +
+                        "lighting angles, volumetric rays, contact shadows, and calibrated denoising parameters (0.35 - 0.45).",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            image_path: {
+                                type: "string",
+                                description: "Path to the reference image.",
+                            },
+                            user_intent: {
+                                type: "string",
+                                description: "Creative intent (e.g. 'golden sunset', 'studio commercial').",
+                            },
+                            target_model: {
+                                type: "string",
+                                enum: ["gpt_image", "nano_banana"],
+                                default: "gpt_image",
+                                description: "Target engine: 'gpt_image' (GPT Image) or 'nano_banana' (Nano Banana).",
+                            },
+                        },
+                        required: ["image_path"],
+                    },
+                },
+            ],
+        };
+    });
+    // Call Tool Handler
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args = {} } = request.params;
+        let envelope;
+        switch (name) {
+            case "analyze_optical_profile": {
+                const imagePath = String(args.image_path || "");
+                envelope = (0, analyze_optical_1.analyzeOpticalProfileTool)(imagePath);
+                break;
+            }
+            case "generate_relight_variations": {
+                const imagePath = String(args.image_path || "");
+                const targetLighting = String(args.target_lighting || "All");
+                const outputDir = String(args.output_dir || "");
+                envelope = (0, generate_relight_1.generateRelightVariationsTool)(imagePath, targetLighting, outputDir);
+                break;
+            }
+            case "harmonize_composite": {
+                const fgPath = String(args.foreground_path || "");
+                const bgPath = String(args.background_path || "");
+                const blendMode = String(args.blend_mode || "seamless");
+                envelope = (0, harmonize_1.harmonizeCompositeTool)(fgPath, bgPath, blendMode);
+                break;
+            }
+            case "synthesize_diffusion_prompt": {
+                const imagePath = String(args.image_path || "");
+                const userIntent = String(args.user_intent || "");
+                const targetModel = String(args.target_model || "gpt_image");
+                envelope = (0, synthesize_prompt_1.synthesizeDiffusionPromptTool)(imagePath, userIntent, targetModel);
+                break;
+            }
+            default:
+                throw new Error(`Unknown tool: '${name}'`);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(envelope, null, 2),
+                },
+            ],
+        };
+    });
+    // List Resources Handler
+    server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
+        return {
+            resources: [
+                {
+                    uri: "optical://presets",
+                    name: "Lighting Presets Specification",
+                    description: "Physical reference definitions for Ambient, Dramatic, Rim, and Mood lighting presets.",
+                    mimeType: "application/json",
+                },
+            ],
+        };
+    });
+    // Read Resource Handler
+    server.setRequestHandler(types_js_1.ReadResourceRequestSchema, async (request) => {
+        if (request.params.uri === "optical://presets") {
+            return {
+                contents: [
+                    {
+                        uri: "optical://presets",
+                        mimeType: "application/json",
+                        text: (0, presets_1.getPresetsJson)(),
+                    },
+                ],
+            };
+        }
+        throw new Error(`Resource not found: '${request.params.uri}'`);
+    });
+    return server;
+}

package/dist/tools/analyze_optical.d.ts

@@ -0,0 +1,2 @@
+import { ResultEnvelope } from "../core/envelope";
+export declare function analyzeOpticalProfileTool(imagePath: string): ResultEnvelope;

package/dist/tools/analyze_optical.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeOpticalProfileTool = analyzeOpticalProfileTool;
+const crypto_1 = __importDefault(require("crypto"));
+const envelope_1 = require("../core/envelope");
+const errors_1 = require("../core/errors");
+const optical_analyzer_1 = require("../domain/optical_analyzer");
+function analyzeOpticalProfileTool(imagePath) {
+    try {
+        const report = (0, optical_analyzer_1.analyzeOpticalProfileImpl)(imagePath);
+        const hash = crypto_1.default.createHash("sha256").update(imagePath).digest("hex").slice(0, 12);
+        return (0, envelope_1.createEnvelope)("success", `Optical profile extracted successfully: ${report.opticalProfileSummary}`, report, {
+            evidence: {
+                inputsDigest: `sha256:${hash}`,
+                sources: [{ label: "Source Image", uri: `file://${report.imagePath}` }],
+            },
+            nextActions: [
+                `Call 'generate_relight_variations' on '${imagePath}' to explore alternative lighting schemes.`,
+                `Call 'synthesize_diffusion_prompt' targeting GPT Image or Nano Banana for high-res generative inpainting.`,
+            ],
+        });
+    }
+    catch (err) {
+        const isAppErr = err instanceof errors_1.AppError;
+        const msg = err.message || "Optical profiling failed.";
+        const code = isAppErr ? err.code : "INTERNAL_ERROR";
+        const hint = isAppErr ? err.actionableHint : "Verify image file accessibility.";
+        return (0, envelope_1.createEnvelope)("failed", `Optical profiling failed: ${msg}`, { error_code: code, actionable_hint: hint }, {
+            warnings: [msg],
+            nextActions: [hint],
+        });
+    }
+}

package/dist/tools/generate_relight.d.ts

@@ -0,0 +1,2 @@
+import { ResultEnvelope } from "../core/envelope";
+export declare function generateRelightVariationsTool(imagePath: string, targetLighting?: string, outputDir?: string): ResultEnvelope;

package/dist/tools/generate_relight.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRelightVariationsTool = generateRelightVariationsTool;
+const crypto_1 = __importDefault(require("crypto"));
+const envelope_1 = require("../core/envelope");
+const errors_1 = require("../core/errors");
+const relighter_1 = require("../domain/relighter");
+function generateRelightVariationsTool(imagePath, targetLighting = "All", outputDir = "") {
+    try {
+        const result = (0, relighter_1.generateRelightVariationsImpl)(imagePath, targetLighting, outputDir);
+        const hash = crypto_1.default.createHash("sha256").update(imagePath).digest("hex").slice(0, 12);
+        const artifacts = result.variations.map((v) => ({
+            label: `${v.presetName} Variation`,
+            uri: `file://${v.imagePath}`,
+        }));
+        const presetNames = result.variations.map((v) => v.presetName).join(", ");
+        return (0, envelope_1.createEnvelope)("success", `Generated ${result.totalVariations} relit variations (${presetNames}) in '${result.outputDir}'.`, result, {
+            evidence: {
+                inputsDigest: `sha256:${hash}`,
+                sources: [{ label: "Input Image", uri: `file://${result.originalImage}` }],
+                artifacts,
+            },
+            nextActions: [
+                "Review generated variation files to inspect aesthetic illumination.",
+                "Use 'synthesize_diffusion_prompt' for GPT Image or Nano Banana generative enhancement.",
+            ],
+        });
+    }
+    catch (err) {
+        const isAppErr = err instanceof errors_1.AppError;
+        const msg = err.message || "Variation generation failed.";
+        const code = isAppErr ? err.code : "INTERNAL_ERROR";
+        const hint = isAppErr ? err.actionableHint : "Check output directory permissions and input image.";
+        return (0, envelope_1.createEnvelope)("failed", `Variation generation failed: ${msg}`, { error_code: code, actionable_hint: hint }, {
+            warnings: [msg],
+            nextActions: [hint],
+        });
+    }
+}

package/dist/tools/harmonize.d.ts

@@ -0,0 +1,2 @@
+import { ResultEnvelope } from "../core/envelope";
+export declare function harmonizeCompositeTool(foregroundPath: string, backgroundPath: string, blendMode?: string): ResultEnvelope;

package/dist/tools/harmonize.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.harmonizeCompositeTool = harmonizeCompositeTool;
+const crypto_1 = __importDefault(require("crypto"));
+const envelope_1 = require("../core/envelope");
+const errors_1 = require("../core/errors");
+const harmonizer_1 = require("../domain/harmonizer");
+function harmonizeCompositeTool(foregroundPath, backgroundPath, blendMode = "seamless") {
+    try {
+        const result = (0, harmonizer_1.harmonizeCompositeImpl)(foregroundPath, backgroundPath, blendMode);
+        const hash = crypto_1.default
+            .createHash("sha256")
+            .update(`${foregroundPath}:${backgroundPath}:${blendMode}`)
+            .digest("hex")
+            .slice(0, 12);
+        return (0, envelope_1.createEnvelope)("success", `Harmonized composite created with matched background color temperature (${result.backgroundCctKelvin}K) and contact shadow.`, result, {
+            evidence: {
+                inputsDigest: `sha256:${hash}`,
+                sources: [
+                    { label: "Foreground Cutout", uri: `file://${result.foregroundPath}` },
+                    { label: "Background Scene", uri: `file://${result.backgroundPath}` },
+                ],
+                artifacts: [
+                    {
+                        label: "Harmonized Composite",
+                        uri: `file://${result.compositeImagePath}`,
+                    },
+                ],
+            },
+            nextActions: [
+                `Inspect the composite output at '${result.compositeImagePath}'.`,
+                "Call 'synthesize_diffusion_prompt' targeting GPT Image or Nano Banana for seamless boundary inpainting.",
+            ],
+        });
+    }
+    catch (err) {
+        const isAppErr = err instanceof errors_1.AppError;
+        const msg = err.message || "Harmonization failed.";
+        const code = isAppErr ? err.code : "INTERNAL_ERROR";
+        const hint = isAppErr ? err.actionableHint : "Ensure foreground and background images are valid files.";
+        return (0, envelope_1.createEnvelope)("failed", `Harmonization failed: ${msg}`, { error_code: code, actionable_hint: hint }, {
+            warnings: [msg],
+            nextActions: [hint],
+        });
+    }
+}

package/dist/tools/synthesize_prompt.d.ts

@@ -0,0 +1,2 @@
+import { ResultEnvelope } from "../core/envelope";
+export declare function synthesizeDiffusionPromptTool(imagePath: string, userIntent?: string, targetModel?: string): ResultEnvelope;

package/dist/tools/synthesize_prompt.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeDiffusionPromptTool = synthesizeDiffusionPromptTool;
+const crypto_1 = __importDefault(require("crypto"));
+const envelope_1 = require("../core/envelope");
+const errors_1 = require("../core/errors");
+const prompt_synthesizer_1 = require("../domain/prompt_synthesizer");
+function synthesizeDiffusionPromptTool(imagePath, userIntent = "", targetModel = "gpt_image") {
+    try {
+        const result = (0, prompt_synthesizer_1.synthesizeDiffusionPromptImpl)(imagePath, userIntent, targetModel);
+        const hash = crypto_1.default
+            .createHash("sha256")
+            .update(`${imagePath}:${targetModel}:${userIntent}`)
+            .digest("hex")
+            .slice(0, 12);
+        return (0, envelope_1.createEnvelope)("success", `Synthesized enhancement and relighting prompts tailored for '${result.targetModel}' with calibrated parameters.`, result, {
+            evidence: {
+                inputsDigest: `sha256:${hash}`,
+                sources: [{ label: "Input Image", uri: `file://${imagePath}` }],
+            },
+            nextActions: [
+                `Paste the 'relightingPrompt' into your ${result.targetModel} generator.`,
+                `Apply suggested denoising strength: ${result.recommendedParameters.denoising_strength}.`,
+            ],
+        });
+    }
+    catch (err) {
+        const isAppErr = err instanceof errors_1.AppError;
+        const msg = err.message || "Prompt synthesis failed.";
+        const code = isAppErr ? err.code : "INTERNAL_ERROR";
+        const hint = isAppErr ? err.actionableHint : "Verify image accessibility and parameters.";
+        return (0, envelope_1.createEnvelope)("failed", `Prompt synthesis failed: ${msg}`, { error_code: code, actionable_hint: hint }, {
+            warnings: [msg],
+            nextActions: [hint],
+        });
+    }
+}

package/docs/architecture.md

@@ -0,0 +1,127 @@
+# Architecture Specification: `mcp-relight-harmonize`
+
+> **MarwanDevSpace Architecture Specification**  
+> Enterprise-grade Model Context Protocol (MCP) server, npm-distributed binary, and Antigravity Skill.
+
+---
+
+## 1. System Overview
+
+`mcp-relight-harmonize` combines deterministic computer vision algorithms, physical color science, and generative AI prompt engineering into a cohesive, composable MCP system.
+
+```text
+               ┌─────────────────────────────────────────────────────────┐
+               │    Client Boundary (Antigravity IDE / Claude Desktop)   │
+               └────────────────────────────┬────────────────────────────┘
+                                            │ stdio (JSON-RPC 2.0)
+                                            ▼
+               ┌─────────────────────────────────────────────────────────┐
+               │         server.py (FastMCP Protocol Assembly)           │
+               └────────────┬───────────────┬──────────────┬─────────────┘
+                            │               │              │
+         ┌──────────────────┼───────────────┼──────────────┼─────────────────┐
+         ▼                  ▼               ▼              ▼                 ▼
+analyze_optical_profile  generate_relight harmonize_comp  synthesize_prompt optical://presets
+         │                  │               │              │                 │
+         ▼                  ▼               ▼              ▼                 ▼
+  src/domain/optical src/domain/relight src/domain/harm  src/domain/prompt src/resources
+         └──────────────────┴───────────────┴──────────────┴─────────────────┘
+                                            │
+                            ┌───────────────┴───────────────┐
+                            │  OpenCV & NumPy & Colour Math │
+                            └───────────────┬───────────────┘
+                                            │
+                            ┌───────────────┴───────────────┐
+                            │     Filesystem Cache & IO     │
+                            └───────────────────────────────┘
+```
+
+---
+
+## 2. Layering, Contracts, and Boundaries
+
+| Layer | Path | Responsibility | Invariants |
+|---|---|---|---|
+| **Protocol / Assembly** | `server.py` | Registers tools and resources with FastMCP. | No raw business math; routes requests to tool adapters. |
+| **Tool Adapters** | `src/tools/` | Translates protocol arguments, executes domain calls, and wraps outputs in the standard result envelope. | Never raises uncaught exceptions to the client; catches and normalizes errors. |
+| **Domain Logic** | `src/domain/` | Pure mathematical operations (CCT, surface normal gradients, Reinhard color transfer, Poisson cloning, prompt templates). | Pure computational logic; no MCP SDK or transport dependencies. |
+| **Contracts** | `src/contracts/` | Pydantic models, schemas, and typed enums. | Source of truth for validation. |
+| **Core Primitives** | `src/core/` | Security guards (`security.py`), error hierarchy (`errors.py`), envelope helpers (`envelope.py`). | Reusable across tools and domain handlers. |
+| **Resources** | `src/resources/` | Static/addressable context (`optical://presets`). | Read-only; zero mutation side-effects. |
+
+---
+
+## 3. Tool Interconnection & Pipeline Chaining Standards
+
+In the MarwanDevSpace design, tools form an interconnected, deterministic pipeline. Downstream tools ingest the physical measurements established by upstream analyzers:
+
+```mermaid
+graph TD
+    A["Input Image"] --> B["analyze_optical_profile"]
+    B -->|CCT, Azimuth, Elevation, Contrast| C["synthesize_diffusion_prompt"]
+    B -->|Profile Evidence Digest| D["generate_relight_variations"]
+    A --> E["harmonize_composite"]
+    E -->|Composite Image + Grounding| C
+    D --> F["4 Relit Variations (Ambient, Dramatic, Rim, Mood)"]
+    C --> G["Model Prompts (Flux, Midjourney, SDXL, IC-Light)"]
+```
+
+### Evidence Chaining Rules
+1. **Inputs Digest:** Each tool computes a canonical `sha256` digest of inputs (`evidence.inputsDigest`).
+2. **Artifact Provenance:** Output files written to disk are listed in `evidence.artifacts` with local file URIs.
+3. **Next-Action Guidance:** Every response provides human- and agent-readable hints in `nextActions` to transition smoothly to the next pipeline stage.
+
+---
+
+## 4. Standard Result Envelope
+
+All MCP tools adhere to the MarwanDevSpace Standard Result Envelope:
+
+```json
+{
+  "status": "success | partial | blocked | failed",
+  "summary": "Human-readable executive summary of the outcome",
+  "data": { /* Domain-specific typed payload */ },
+  "warnings": [ /* Non-fatal warnings */ ],
+  "evidence": {
+    "inputsDigest": "sha256:...",
+    "sources": [ { "label": "...", "uri": "file://..." } ],
+    "artifacts": [ { "label": "...", "uri": "file://...", "sha256": "..." } ]
+  },
+  "nextActions": [ "Suggested subsequent tool calls" ]
+}
+```
+
+---
+
+## 5. NPM & GitHub Distribution Architecture
+
+The project is dual-packaged for Python and Node.js ecosystems:
+
+- **`package.json`**: NPM package manifest enabling installation and execution via `npx mcp-relight-harmonize`.
+- **`bin/mcp-relight-harmonize.js`**: Cross-platform Node.js launcher that detects local virtual environments (`.venv`) or system Python and establishes stdio stdio communication.
+- **`.github/workflows/ci.yml`**: Continuous Integration testing across Python 3.10/3.11 and Node 18/20, running Pytest, launcher verification, and `npm pack --dry-run`.
+
+---
+
+## 6. Antigravity Skill Ecosystem (`.agents/skills/`)
+
+The repository integrates directly into the Antigravity agent architecture as an on-demand skill:
+
+```text
+.agents/skills/mcp-relight-harmonize/
+├── SKILL.md                          # Main agent instructions with YAML frontmatter
+├── references/
+│   ├── optical_math.md               # CIE XYZ, McCamy CCT, Normal tensors, Reinhard
+│   ├── tool_orchestration.md         # Interconnection criteria, evidence chaining, fallback rules
+│   └── diffusion_guide.md            # Prompt tokens & parameters for Flux/MJ/SDXL/IC-Light
+└── scripts/
+    ├── run_pipeline.py               # Standalone CLI pipeline runner
+    └── verify_server.py              # Self-contained tool & resource verifier
+```
+
+---
+
+## 7. Master Persona Reference (`MASTER.md`)
+
+The governance, technical standards, and voice of the repository are anchored in [MASTER.md](../MASTER.md), enforcing protocol purity, optical realism, security boundaries, and release quality gates.

package/docs/operations.md

@@ -0,0 +1,27 @@
+# Operational Runbook: `mcp-relight-harmonize`
+
+## 1. Prerequisites
+- Node.js >= 18.0.0
+- npm >= 9.0.0
+
+## 2. Setup and Compilation
+```bash
+npm install
+npm run build
+```
+
+## 3. Verification & Testing
+Execute automated test suite:
+```bash
+npm test
+```
+
+Perform runtime verification:
+```bash
+npm run verify
+```
+
+## 4. Configuration
+| Environment Variable | Default | Description |
+|---|---|---|
+| `OUTPUT_CACHE_DIR` | `./generated_variations` | Destination folder for relit variations and harmonized composites. |

package/docs/security.md

@@ -0,0 +1,17 @@
+# Security & Trust Boundaries: `mcp-relight-harmonize`
+
+## 1. Threat Model
+The server operates locally via `stdio` transport. Although executed within the host environment, it implements proactive defenses against malicious or unverified inputs.
+
+| Threat | Risk | Mitigation |
+|---|---|---|
+| **Path Traversal (`../..`)** | Unauthorized file disclosure | `validate_and_resolve_path()` canonicalizes paths with `Path.resolve()` and checks boundaries. |
+| **Unsupported / Malicious Files** | Parsing bugs or remote code execution | Strict extension allowlist (`.png`, `.jpg`, `.jpeg`, `.webp`, `.bmp`, `.tiff`) and image header validation. |
+| **Denial of Service (Decompression Bombs)** | Memory exhaustion | File size cap (`MAX_FILE_SIZE_BYTES = 50 MB`) and dimension validation prior to processing. |
+| **Secret Leakage** | Exposure of private paths / tokens | Standard error envelopes redact raw system internals, returning normalized error codes and actionable hints. |
+
+## 2. Destructive Operations
+- `analyze_optical_profile`: Read-only.
+- `synthesize_diffusion_prompt`: Read-only / pure computation.
+- `generate_relight_variations`: Writes variation images to designated output directory (`OUTPUT_CACHE_DIR`).
+- `harmonize_composite`: Writes composited image to designated output directory.

package/mcp_config.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "mcp-relight-harmonize": {
+      "command": "node",
+      "args": [
+        "c:/Users/DKurdistan/Desktop/mcp-relight-harmonize/dist/index.js"
+      ],
+      "env": {
+        "OUTPUT_CACHE_DIR": "./generated_variations"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "mcp-relight-harmonize",
+  "version": "1.0.0",
+  "description": "Professional TypeScript Model Context Protocol (MCP) server & agent skill for optical profiling, physical relighting, composite harmonization, and diffusion prompt synthesis (GPT Image & Nano Banana).",
+  "author": "MarwanDevSpace <dev@marwandevspace.io>",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-relight-harmonize": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MarwanDevSpace/mcp-relight-harmonize.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MarwanDevSpace/mcp-relight-harmonize/issues"
+  },
+  "homepage": "https://github.com/MarwanDevSpace/mcp-relight-harmonize#readme",
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "antigravity",
+    "relight",
+    "harmonize",
+    "optical-analysis",
+    "gpt-image",
+    "nano-banana",
+    "marwandevspace"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "verify": "node dist/index.js --verify"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "jpeg-js": "^0.4.4",
+    "pngjs": "^7.0.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.8",
+    "@types/pngjs": "^6.0.5",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.7"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "MASTER.md",
+    "mcp_config.json",
+    ".agents",
+    "docs",
+    "README.md"
+  ]
+}