@playcraft/cli 0.0.25 → 0.0.27

package/dist/commands/image.js

@@ -48,6 +48,157 @@ function handleError(err) {
     console.error(`Error: ${msg}`);
     process.exit(1);
 }
+/**
+ * 从图片四条边向内 BFS flood-fill，自动检测边缘主色并移除连通的同色背景区域。
+ * 适用于 AI 生成的素材（纯色、灰色、棋盘格背景），前景纹理零损失。
+ */
+async function floodFillRemoveBg(inputPath, opts) {
+    const { data, info } = await sharp(inputPath)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const w = info.width;
+    const h = info.height;
+    const totalPixels = w * h;
+    const result = Buffer.from(data);
+    const tolerance = opts.tolerance;
+    // ── 1. Auto-detect background colors from edge pixels ──
+    const edgeSamples = [];
+    const px = (x, y) => {
+        const i = (y * w + x) * 4;
+        return { r: data[i], g: data[i + 1], b: data[i + 2] };
+    };
+    for (let x = 0; x < w; x++) {
+        edgeSamples.push(px(x, 0), px(x, h - 1));
+    }
+    for (let y = 1; y < h - 1; y++) {
+        edgeSamples.push(px(0, y), px(w - 1, y));
+    }
+    const clusters = [];
+    for (const s of edgeSamples) {
+        let matched = false;
+        for (const c of clusters) {
+            if (Math.abs(c.r - s.r) < 30 &&
+                Math.abs(c.g - s.g) < 30 &&
+                Math.abs(c.b - s.b) < 30) {
+                c.r = (c.r * c.count + s.r) / (c.count + 1);
+                c.g = (c.g * c.count + s.g) / (c.count + 1);
+                c.b = (c.b * c.count + s.b) / (c.count + 1);
+                c.count++;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            clusters.push({ r: s.r, g: s.g, b: s.b, count: 1 });
+    }
+    clusters.sort((a, b) => b.count - a.count);
+    const bgColors = clusters
+        .slice(0, 3)
+        .filter((c) => c.count > edgeSamples.length * 0.05);
+    if (!bgColors.length) {
+        const out = await sharp(result, {
+            raw: { width: w, height: h, channels: 4 },
+        })
+            .png()
+            .toBuffer();
+        return { buffer: out, removedPct: 0, bgColors: [] };
+    }
+    const isBg = (idx) => {
+        const r = data[idx];
+        const g = data[idx + 1];
+        const b = data[idx + 2];
+        return bgColors.some((bg) => Math.abs(r - bg.r) < tolerance &&
+            Math.abs(g - bg.g) < tolerance &&
+            Math.abs(b - bg.b) < tolerance);
+    };
+    // ── 2. BFS flood-fill from edges ──
+    const visited = new Uint8Array(totalPixels);
+    const queue = [];
+    for (let x = 0; x < w; x++) {
+        queue.push(x, (h - 1) * w + x);
+    }
+    for (let y = 1; y < h - 1; y++) {
+        queue.push(y * w, y * w + (w - 1));
+    }
+    let qi = 0;
+    while (qi < queue.length) {
+        const pos = queue[qi++];
+        if (pos < 0 || pos >= totalPixels || visited[pos])
+            continue;
+        if (!isBg(pos * 4))
+            continue;
+        visited[pos] = 1;
+        result[pos * 4 + 3] = 0;
+        const x = pos % w;
+        const y = (pos - x) / w;
+        if (x > 0)
+            queue.push(pos - 1);
+        if (x < w - 1)
+            queue.push(pos + 1);
+        if (y > 0)
+            queue.push(pos - w);
+        if (y < h - 1)
+            queue.push(pos + w);
+    }
+    // ── 3. Edge smoothing (multi-layer alpha gradient) ──
+    if (opts.edgeLayers > 0) {
+        const layerAlphas = [200, 120, 60];
+        let borderSet = new Set();
+        for (let y = 1; y < h - 1; y++) {
+            for (let x = 1; x < w - 1; x++) {
+                const pos = y * w + x;
+                if (result[pos * 4 + 3] === 0)
+                    continue;
+                const nb = [pos - 1, pos + 1, pos - w, pos + w];
+                if (nb.some((n) => result[n * 4 + 3] === 0))
+                    borderSet.add(pos);
+            }
+        }
+        for (let layer = 0; layer < opts.edgeLayers && layer < layerAlphas.length; layer++) {
+            const alpha = layerAlphas[layer];
+            for (const pos of borderSet) {
+                result[pos * 4 + 3] = Math.min(result[pos * 4 + 3], alpha);
+            }
+            if (layer < opts.edgeLayers - 1) {
+                const nextBorder = new Set();
+                for (const pos of borderSet) {
+                    const x = pos % w;
+                    const y = (pos - x) / w;
+                    for (const [dx, dy] of [[-1, 0], [1, 0], [0, -1], [0, 1]]) {
+                        const nx = x + dx;
+                        const ny = y + dy;
+                        if (nx < 0 || nx >= w || ny < 0 || ny >= h)
+                            continue;
+                        const npos = ny * w + nx;
+                        if (result[npos * 4 + 3] === 0 && !borderSet.has(npos)) {
+                            result[npos * 4 + 3] = Math.min(60, layerAlphas[layer + 1] ?? 40);
+                            nextBorder.add(npos);
+                        }
+                    }
+                }
+                borderSet = nextBorder;
+            }
+        }
+    }
+    let removed = 0;
+    for (let i = 0; i < totalPixels; i++) {
+        if (result[i * 4 + 3] === 0)
+            removed++;
+    }
+    const outBuf = await sharp(result, {
+        raw: { width: w, height: h, channels: 4 },
+    })
+        .png()
+        .toBuffer();
+    const bgLabels = bgColors.map((c) => `rgb(${Math.round(c.r)},${Math.round(c.g)},${Math.round(c.b)})`);
+    return {
+        buffer: outBuf,
+        removedPct: (removed / totalPixels) * 100,
+        bgColors: bgLabels,
+    };
+}
+// ─── CLI helpers ────────────────────────────────────────────────────────────
 /** CLI --fit  → sharp resize `fit`（非法则退出并提示） */
 function parseResizeFitOption(raw) {
     const v = (raw ?? 'cover').toLowerCase();
@@ -451,21 +602,74 @@ export function registerImageCommands(program) {
             handleError(e);
         }
     });
-    // ─── remove-background（AI 背景移除，调用 backend）────────────
+    // ─── remove-background ─────────────────────────────────────────
     img.command('remove-background')
-        .description('AI 背景移除，输出透明 PNG（模型运行在 backend，无需沙箱加载大模型）')
+        .description([
+        '背景移除，输出透明 PNG。支持两种方法（--method 选择）：',
+        '',
+        '  floodfill（默认）— 从图片边缘 flood-fill 移除纯色/渐变/棋盘格背景',
+        '    ✅ 适用：AI 生成的素材（纯色背景、灰色背景、棋盘格背景）',
+        '    ✅ 优势：前景纹理零损失、速度快（<0.5s）、完全本地执行',
+        '    ⚠️ 局限：仅能移除从边缘连通的简单背景；复杂场景照片无效',
+        '',
+        '  ai — 基于 @imgly/background-removal-node 的 AI 语义分割',
+        '    ✅ 适用：真实照片、复杂背景、前景与背景颜色相近的场景',
+        '    ⚠️ 局限：对浅色纹理前景（如木纹麻将牌）可能误判导致褪色；需调用 backend API',
+        '',
+        '  选择建议：',
+        '    - AI 生图的素材（Gemini 等），背景通常为纯色/棋盘格 → 用 floodfill',
+        '    - 真实照片或背景极复杂 → 用 ai',
+        '    - 不确定时 → 先试 floodfill，效果不好再换 ai',
+    ].join('\n'))
         .requiredOption('--input <path>', '输入图片路径')
         .requiredOption('--output <path>', '输出路径（必须是 .png，保留透明通道）')
+        .option('--method <method>', 'floodfill（本地颜色 flood-fill，默认）或 ai（AI 模型，调用 backend）', 'floodfill')
+        .option('--tolerance <n>', '[floodfill] 颜色容差 0-255（越大越激进，默认 30）', cliParseInt, 30)
+        .option('--edge-smooth <n>', '[floodfill] 边缘平滑层数 0-4（0=硬边，默认 2）', cliParseInt, 2)
+        .option('--model <size>', '[ai] 抠图模型：small / medium（默认 medium）', 'medium')
+        .option('--no-refine', '[ai] 跳过 alpha 后处理（保留模型原始软边）')
         .action(async (opts) => {
         try {
             assertInputWithinLimit(opts.input);
-            const imageBase64 = readFileSync(opts.input).toString('base64');
-            const client = new AgentApiClient();
-            const result = await client.post('/remove-background', { imageBase64 });
-            const buf = Buffer.from(result.imageBase64, 'base64');
-            writeOutput(opts.output, buf);
-            const origSize = statSync(opts.input).size;
-            console.log(`Background removed: ${opts.output} (${sizeLabel(buf)}, orig ${sizeLabelBytes(origSize)})`);
+            const method = opts.method ?? 'floodfill';
+            if (method === 'floodfill') {
+                const t0 = Date.now();
+                const { buffer, removedPct, bgColors } = await floodFillRemoveBg(opts.input, {
+                    tolerance: opts.tolerance ?? 30,
+                    edgeLayers: Math.min(opts.edgeSmooth ?? 2, 4),
+                });
+                writeOutput(opts.output, buffer);
+                const elapsed = ((Date.now() - t0) / 1000).toFixed(2);
+                const origSize = statSync(opts.input).size;
+                console.log(`Background removed (floodfill): ${opts.output} (${sizeLabel(buffer)}, orig ${sizeLabelBytes(origSize)}, ${elapsed}s)`);
+                console.log(`  detected bg: ${bgColors.join(', ') || 'none'} | removed ${removedPct.toFixed(1)}% pixels | tolerance=${opts.tolerance} edge-smooth=${opts.edgeSmooth ?? 2}`);
+                if (removedPct < 5) {
+                    console.log('  ⚠️  移除比例很低，背景可能较复杂。建议尝试 --method ai 或增大 --tolerance');
+                }
+            }
+            else if (method === 'ai') {
+                const imageBase64 = readFileSync(opts.input).toString('base64');
+                const model = opts.model;
+                if (model && !['small', 'medium', 'large'].includes(model)) {
+                    console.error('Error: --model must be small, medium, or large');
+                    process.exit(1);
+                }
+                const client = new AgentApiClient();
+                const payload = {
+                    imageBase64,
+                    model: model ?? 'medium',
+                    refineAlpha: opts.refine !== false,
+                };
+                const result = await client.post('/remove-background', payload);
+                const buf = Buffer.from(result.imageBase64, 'base64');
+                writeOutput(opts.output, buf);
+                const origSize = statSync(opts.input).size;
+                console.log(`Background removed (ai/${model}): ${opts.output} (${sizeLabel(buf)}, orig ${sizeLabelBytes(origSize)})`);
+            }
+            else {
+                console.error('Error: --method must be floodfill or ai');
+                process.exit(1);
+            }
         }
         catch (e) {
             handleError(e);

package/dist/commands/tools.js

@@ -91,36 +91,44 @@ function resolveImageOutputPath(outputPath, wantExt) {
     }
     return join(dir, `${name}${wantExt}`);
 }
+function collectReferenceImagePaths(value, previous) {
+    return previous.concat([value]);
+}
+function mimeTypeForImagePath(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    if (ext === 'png')
+        return 'image/png';
+    if (ext === 'webp')
+        return 'image/webp';
+    return 'image/jpeg';
+}
 export function registerToolsCommands(program) {
     const tools = program
         .command('tools')
         .description('后端 /api/agent/tools；需 PLAYCRAFT_API_URL + PLAYCRAFT_SANDBOX_TOKEN 或 .playcraft.json');
     // ─── Generation ─────────────────────────────────────────────
     tools.command('generate-image')
-        .description('AI 生成图片（支持参考图图生图）')
+        .description('AI 生成图片（支持多张参考图图生图）')
         .requiredOption('--prompt <text>', '图片描述')
         .option('--aspect-ratio <ratio>', '宽高比 (1:1|16:9|9:16|3:4|4:3)', '1:1')
         .requiredOption('--output <path>', '保存路径')
         .option('--image-size <size>', '图片尺寸 (1K|2K|4K)')
-        .option('--reference-image <path>', '参考图路径（图生图），支持 PNG/JPG/WEBP')
+        .option('--reference-image <path>', '参考图路径（可重复多次，最多 8 张），支持 PNG/JPG/WEBP', collectReferenceImagePaths, [])
         .action(async (opts) => {
         try {
-            let referenceImageBase64;
-            let referenceImageMimeType;
-            if (opts.referenceImage) {
-                const imgBuf = readFileSync(opts.referenceImage);
-                referenceImageBase64 = imgBuf.toString('base64');
-                const ext = opts.referenceImage.split('.').pop()?.toLowerCase();
-                referenceImageMimeType =
-                    ext === 'png' ? 'image/png' : ext === 'webp' ? 'image/webp' : 'image/jpeg';
-            }
+            const paths = opts.referenceImage ?? [];
+            const referenceImages = paths.length > 0
+                ? paths.map((p) => ({
+                    base64: readFileSync(p).toString('base64'),
+                    mimeType: mimeTypeForImagePath(p),
+                }))
+                : undefined;
             const client = new AgentApiClient();
             const result = await client.post('/generate-image', {
                 prompt: opts.prompt,
                 aspectRatio: opts.aspectRatio,
                 imageSize: opts.imageSize,
-                referenceImageBase64,
-                referenceImageMimeType,
+                referenceImages,
             });
             const buf = Buffer.from(result.imageBase64, 'base64');
             const sniffed = sniffImageExtension(buf);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "private": false,
   "type": "module",
   "bin": {
@@ -22,8 +22,8 @@
     "release": "node scripts/release.js"
   },
   "dependencies": {
-    "@playcraft/build": "^0.0.25",
-    "@playcraft/common": "^0.0.14",
+    "@playcraft/build": "^0.0.27",
+    "@playcraft/common": "^0.0.16",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "cors": "^2.8.6",