@edmund32/edx-cli 0.1.2

package/src/commands/image.mjs

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { fail, ok } from '../utils/result.mjs';
+import { mergeImages } from '../image/merge.mjs';
+import { splitGrid, splitRegion } from '../image/split.mjs';
+
+const PROJECT_DIRS = ['1.src', '2.pick', '3.cleaned', '4.deepfake', '5.picMark', '6.dst'];
+
+function help() {
+  return [
+    '--- edx-image 可用的指令集列表 ---',
+    'edx-image 是 Edmund 常用的图片对象处理指令集，主要用于图片项目目录创建、图片分割和图片拼接。',
+    '',
+    '1. edx-image mkdir <项目名>',
+    '   说明: 创建 Edmund 图片处理项目目录结构，自动生成 1.src、2.pick、3.cleaned 等常用阶段目录。',
+    '',
+    '2. edx-image split grid <target> --rows <n> --cols <n>',
+    '   说明: 按行列把图片切成多个小图，适合九宫格、四宫格或其他固定网格分割。',
+    '   输出: 在 target 同级生成 target_output/，每张原图会生成一个同名文件夹保存切分结果。',
+    '',
+    '3. edx-image split region <target> --from <x,y> --to <x,y>',
+    '   说明: 按左下角比例坐标裁切指定区域，坐标范围是 0-1。',
+    '   示例: --from 0.5,0 --to 1,1 表示裁切右半边。',
+    '',
+    '4. edx-image merge <target> --rows <n> [--cols <n>] [--cellw <px> --cellh <px>]',
+    '   说明: 把文件夹图片按网格拼接成大图，支持递归处理子文件夹。',
+    '   输出: 在 target 同级生成 target_merged/，每个含图片的文件夹输出一张 png。',
+    '--------------------------',
+  ].join('\n');
+}
+
+function createProject(args) {
+  if (args.length !== 1) {
+    return fail('用法: edx-image mkdir <项目名>');
+  }
+
+  const project = args[0];
+  fs.mkdirSync(project, { recursive: true });
+
+  for (const dir of PROJECT_DIRS) {
+    fs.mkdirSync(path.join(project, dir), { recursive: true });
+  }
+
+  return ok(`项目目录 '${path.basename(project)}' 已创建，包含以下子目录：\n${PROJECT_DIRS.join('\n')}`);
+}
+
+function parseOptions(args) {
+  const positionals = [];
+  const flags = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const value = args[i + 1];
+
+      if (!value || value.startsWith('--')) {
+        throw new Error(`缺少参数: ${arg}`);
+      }
+
+      flags[key] = value;
+      i += 1;
+    } else {
+      positionals.push(arg);
+    }
+  }
+
+  return {
+    positionals,
+    flags,
+  };
+}
+
+function splitSummary(label, result) {
+  const lines = [
+    `开始: ${label}`,
+    `输出目录: ${result.outputRoot}`,
+    ...result.logs,
+    `${label} 完成`,
+    `输出文件: ${result.outputs.length}`,
+  ];
+
+  if (result.errors.length > 0) {
+    lines.push(`失败文件: ${result.errors.length}`);
+    for (const error of result.errors) {
+      lines.push(`- ${error.filePath}: ${error.message}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function mergeSummary(result) {
+  const lines = [
+    '开始: merge 拼接',
+    `输出目录: ${result.outputRoot}`,
+    ...result.logs,
+    'merge 拼接 完成',
+    `输出文件: ${result.outputs.length}`,
+  ];
+
+  if (result.errors.length > 0) {
+    lines.push(`失败文件夹: ${result.errors.length}`);
+    for (const error of result.errors) {
+      lines.push(`- ${error.filePath}: ${error.message}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+async function runSplitCommand(args) {
+  const [mode, ...rest] = args;
+
+  if (!mode || mode === '-h' || mode === '--help' || mode === 'help') {
+    return ok([
+      '用法:',
+      '  edx-image split grid <target> --rows <n> --cols <n>',
+      '  edx-image split region <target> --from <x,y> --to <x,y>',
+      '',
+      '说明:',
+      '  region 坐标使用 0-1 比例，原点在左下角。',
+      '  右半边裁切可写为: edx-image split region <target> --from 0.5,0 --to 1,1',
+    ].join('\n'));
+  }
+
+  try {
+    const { positionals, flags } = parseOptions(rest);
+    const target = positionals[0];
+
+    if (!target) {
+      return fail('错误: 缺少 target 路径');
+    }
+
+    if (mode === 'grid') {
+      const result = await splitGrid(target, {
+        rows: flags.rows,
+        cols: flags.cols,
+      });
+
+      return ok(splitSummary('grid 分割', result));
+    }
+
+    if (mode === 'region') {
+      const result = await splitRegion(target, {
+        from: flags.from,
+        to: flags.to,
+      });
+
+      return ok(splitSummary('region 裁切', result));
+    }
+
+    return fail(`错误: 未知 split 模式 '${mode}'`);
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+}
+
+async function runMergeCommand(args) {
+  if (args.length === 0 || args[0] === '-h' || args[0] === '--help' || args[0] === 'help') {
+    return ok([
+      '用法:',
+      '  edx-image merge <target> --rows <n> [--cols <n>] [--cellw <px> --cellh <px>]',
+      '',
+      '说明:',
+      '  处理 target 文件夹及其递归子文件夹中的图片。',
+      '  每个含图片的文件夹会拼接成一张 png，统一输出到 target 同级的 target_merged/。',
+      '  输出目录只有一层，例如 target/A/*.png -> target_merged/A.png。',
+      '  --cols 省略时按图片数量和 --rows 自动计算列数。',
+      '  图片不足固定网格时用黑色占位；图片超出固定网格时按名称排序取前面的图片。',
+    ].join('\n'));
+  }
+
+  try {
+    const { positionals, flags } = parseOptions(args);
+    const target = positionals[0];
+
+    if (!target) {
+      return fail('错误: 缺少 target 路径');
+    }
+
+    const result = await mergeImages(target, {
+      rows: flags.rows,
+      cols: flags.cols,
+      cellw: flags.cellw,
+      cellh: flags.cellh,
+    });
+
+    return ok(mergeSummary(result));
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+}
+
+export async function runImageCommand(args) {
+  const [command, ...rest] = args;
+
+  if (!command || command === '-a' || command === '--help' || command === 'help') {
+    return ok(help());
+  }
+
+  if (command === 'mkdir') {
+    return createProject(rest);
+  }
+
+  if (command === 'split') {
+    return runSplitCommand(rest);
+  }
+
+  if (command === 'merge') {
+    return runMergeCommand(rest);
+  }
+
+  return fail(`错误: 未知动作 '${command}'\n${help()}`);
+}

package/src/commands/md.mjs

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { fail, ok } from '../utils/result.mjs';
+
+function usage() {
+  return '用法: edx-md copy <旧.md> <新.md>';
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function copyMarkdownAssets(oldMd, newMd) {
+  if (!fs.existsSync(oldMd) || !fs.statSync(oldMd).isFile()) {
+    return fail(`错误: 旧文件 '${oldMd}' 不存在。`);
+  }
+  if (!fs.existsSync(newMd) || !fs.statSync(newMd).isFile()) {
+    return fail(`错误: 新文件 '${newMd}' 不存在（请先手动复制文字内容）。`);
+  }
+
+  const oldBase = oldMd.replace(/\.md$/i, '');
+  const newBase = newMd.replace(/\.md$/i, '');
+  const oldAssets = `${oldBase}.assets`;
+  const newAssets = `${newBase}.assets`;
+  const oldAssetsName = path.basename(oldAssets);
+  const newAssetsName = path.basename(newAssets);
+
+  if (!fs.existsSync(oldAssets) || !fs.statSync(oldAssets).isDirectory()) {
+    return fail(`错误: 旧资源目录 '${oldAssets}' 不存在。`);
+  }
+
+  const markdown = fs.readFileSync(newMd, 'utf8');
+  const assetPattern = new RegExp(`(?:\\.\\/)?${escapeRegExp(oldAssetsName)}\\/[^\\s"'\\)]+`, 'g');
+  const references = [...new Set(markdown.match(assetPattern) ?? [])];
+
+  if (references.length === 0) {
+    return ok('未找到任何引用旧资源的图片，无需处理。');
+  }
+
+  fs.mkdirSync(newAssets, { recursive: true });
+
+  const copied = [];
+  const missing = [];
+
+  for (const reference of references) {
+    const normalized = reference.replace(/^\.\//, '');
+    const fileName = path.basename(normalized);
+    const source = path.join(oldAssets, fileName);
+    const target = path.join(newAssets, fileName);
+
+    if (!fs.existsSync(source)) {
+      missing.push(source);
+      continue;
+    }
+
+    if (!fs.existsSync(target)) {
+      fs.copyFileSync(source, target);
+    }
+    copied.push(fileName);
+  }
+
+  const rewritten = markdown.replaceAll(`${oldAssetsName}/`, `${newAssetsName}/`);
+  fs.writeFileSync(newMd, rewritten);
+
+  const lines = [
+    `旧文件: ${oldMd} -> 新文件: ${newMd}`,
+    `旧资源: ${oldAssets} -> 新资源: ${newAssets}`,
+    `已处理 ${copied.length} 个资源引用。`,
+  ];
+
+  for (const item of missing) {
+    lines.push(`源文件缺失，跳过: ${item}`);
+  }
+
+  return ok(lines.join('\n'));
+}
+
+export async function runMdCommand(args) {
+  const [command, oldMd, newMd] = args;
+
+  if (!command || command === '-a' || command === '--help' || command === 'help') {
+    return ok(usage());
+  }
+
+  if (command !== 'copy' || args.length !== 3) {
+    return fail(usage());
+  }
+
+  return copyMarkdownAssets(oldMd, newMd);
+}

package/src/image/merge.mjs

@@ -0,0 +1,233 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import sharp from 'sharp';
+
+const IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.webp']);
+
+function isImageFile(filePath) {
+  return IMAGE_EXTS.has(path.extname(filePath).toLowerCase());
+}
+
+function sortNames(a, b) {
+  return a.localeCompare(b, 'zh-Hans-CN', { numeric: true });
+}
+
+function parsePositiveInteger(value, name) {
+  const parsed = Number(value);
+
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new Error(`${name} 必须是正整数`);
+  }
+
+  return parsed;
+}
+
+function optionalPositiveInteger(value, name) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return parsePositiveInteger(value, name);
+}
+
+function buildMergeOutputRoot(targetPath) {
+  const absoluteTarget = path.resolve(targetPath);
+  const parent = path.dirname(absoluteTarget);
+  const name = path.basename(absoluteTarget);
+
+  return path.join(parent, `${name}_merged`);
+}
+
+function collectImageGroups(targetPath) {
+  const absoluteTarget = path.resolve(targetPath);
+
+  if (!fs.existsSync(absoluteTarget)) {
+    throw new Error(`找不到 target: ${targetPath}`);
+  }
+
+  const targetStat = fs.statSync(absoluteTarget);
+
+  if (!targetStat.isDirectory()) {
+    throw new Error(`target 必须是文件夹: ${targetPath}`);
+  }
+
+  const groups = [];
+
+  function walk(currentDir) {
+    const entries = fs.readdirSync(currentDir).sort(sortNames);
+    const files = [];
+    const dirs = [];
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry);
+      const stat = fs.statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        dirs.push(fullPath);
+      } else if (stat.isFile() && isImageFile(fullPath)) {
+        files.push(fullPath);
+      }
+    }
+
+    if (files.length > 0) {
+      groups.push({
+        dirPath: currentDir,
+        name: path.basename(currentDir),
+        files,
+      });
+    }
+
+    for (const dir of dirs) {
+      walk(dir);
+    }
+  }
+
+  walk(absoluteTarget);
+  return groups;
+}
+
+function uniqueOutputPath(outputRoot, name, usedNames) {
+  let index = 1;
+
+  while (true) {
+    const suffix = index === 1 ? '' : `_${index}`;
+    const fileName = `${name}${suffix}.png`;
+
+    if (!usedNames.has(fileName)) {
+      usedNames.add(fileName);
+      return path.join(outputRoot, fileName);
+    }
+
+    index += 1;
+  }
+}
+
+async function resolveCellSize(files, options) {
+  if (options.cellw && options.cellh) {
+    return {
+      width: options.cellw,
+      height: options.cellh,
+    };
+  }
+
+  const meta = await sharp(files[0]).metadata();
+
+  if (!meta.width || !meta.height) {
+    throw new Error('无法读取图片尺寸');
+  }
+
+  return {
+    width: options.cellw ?? options.cellh ?? meta.width,
+    height: options.cellh ?? options.cellw ?? meta.height,
+  };
+}
+
+async function composeGroup(group, outputRoot, options, current, total, usedNames) {
+  const rows = options.rows;
+  const cols = options.cols ?? Math.ceil(group.files.length / rows);
+  const totalCells = rows * cols;
+  const selected = group.files.slice(0, totalCells);
+  const placeholders = totalCells - selected.length;
+  const cell = await resolveCellSize(selected, options);
+  const width = cols * cell.width;
+  const height = rows * cell.height;
+  const composites = [];
+
+  for (let index = 0; index < selected.length; index++) {
+    const row = Math.floor(index / cols);
+    const col = index % cols;
+    const input = await sharp(selected[index])
+      .resize(cell.width, cell.height, { fit: 'fill' })
+      .png()
+      .toBuffer();
+
+    composites.push({
+      input,
+      left: col * cell.width,
+      top: row * cell.height,
+    });
+  }
+
+  const outputPath = uniqueOutputPath(outputRoot, group.name, usedNames);
+  await sharp({
+    create: {
+      width,
+      height,
+      channels: 4,
+      background: '#000000',
+    },
+  })
+    .composite(composites)
+    .png()
+    .toFile(outputPath);
+
+  return {
+    outputPath,
+    logs: [
+      `处理 ${current}/${total}: ${group.name}`,
+      `选中图片: ${selected.length}/${group.files.length}`,
+      `占位: ${placeholders}`,
+      `完成 ${current}/${total}: ${group.name} -> ${path.basename(outputPath)}`,
+    ],
+  };
+}
+
+export async function mergeImages(targetPath, options) {
+  const rows = parsePositiveInteger(options.rows, '--rows');
+  const cols = optionalPositiveInteger(options.cols, '--cols');
+  const rawCellW = optionalPositiveInteger(options.cellw, '--cellw');
+  const rawCellH = optionalPositiveInteger(options.cellh, '--cellh');
+  const cellw = rawCellW ?? rawCellH;
+  const cellh = rawCellH ?? rawCellW;
+  const groups = collectImageGroups(targetPath);
+  const outputRoot = buildMergeOutputRoot(targetPath);
+  const outputs = [];
+  const errors = [];
+  const logs = [];
+  const usedNames = new Set();
+
+  fs.mkdirSync(outputRoot, { recursive: true });
+
+  if (groups.length === 0) {
+    logs.push('未找到可处理图片文件夹');
+  }
+
+  for (let index = 0; index < groups.length; index++) {
+    const group = groups[index];
+    const current = index + 1;
+
+    try {
+      const result = await composeGroup(
+        group,
+        outputRoot,
+        {
+          rows,
+          cols,
+          cellw,
+          cellh,
+        },
+        current,
+        groups.length,
+        usedNames,
+      );
+
+      outputs.push(result.outputPath);
+      logs.push(...result.logs);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push({
+        filePath: group.dirPath,
+        message,
+      });
+      logs.push(`处理 ${current}/${groups.length}: ${group.name}`);
+      logs.push(`失败 ${current}/${groups.length}: ${group.name} -> ${message}`);
+    }
+  }
+
+  return {
+    outputRoot,
+    outputs,
+    errors,
+    logs,
+  };
+}