Pw Image Generation

# 项目 .gitignore 文件

# 依赖
node_modules/
package-lock.json
yarn.lock

# 配置文件
config/secrets.md
config/local.config.js
config/.env*

# 输出文件
output/
*.log
*.tmp

# 编辑器
.vscode/
.idea/
*.swp
*.swo
*~

# 系统
.DS_Store
Thumbs.db

# 临时文件
*.tmp
*.temp

.DS_Store
node_modules/
package-lock.json
*.log
prompts/
images/
analysis/
references/

# 项目 .gitignore 文件

# 依赖
node_modules/
package-lock.json
yarn.lock

# 配置文件
config/secrets.md
config/local.config.js
config/.env*

# 输出文件
output/
*.log
*.tmp

# 编辑器
.vscode/
.idea/
*.swp
*.swo
*~

# 系统
.DS_Store
Thumbs.db

# 临时文件
*.tmp
*.temp

#!/usr/bin/env bun

/**
 * 分析图像的风格和特征
 *
 * 使用方法：
 * npx -y bun ${SKILL_DIR}/scripts/analyze-image.ts <图像URL或路径> [输出目录]
 *
 * 示例：
 * npx -y bun ${SKILL_DIR}/scripts/analyze-image.ts https://example.com/image.png
 * npx -y bun ${SKILL_DIR}/scripts/analyze-image.ts ./local-image.png ./output
 */

import fs from 'fs';
import path from 'path';
import https from 'https';
import http from 'http';

// 配置类型定义
interface Config {
  API_BASE_URL: string;
  ANALYSIS_MODEL_ID: string;
  GENERATION_MODEL_ID: string;
  ANALYSIS_ENDPOINT: string;
  GENERATION_ENDPOINT: string;
  API_KEY: string;
  IMAGE_UPLOAD_ENDPOINT: string;
}

// 读取配置（支持默认配置）
function loadConfig(): Config {
  const configPath = path.join(process.cwd(), 'config', 'secrets.md');
  const defaultConfig: Config = {
    API_BASE_URL: 'https://ai-router.plugins-world.cn',
    ANALYSIS_MODEL_ID: 'gemini-2.0-flash-exp',
    GENERATION_MODEL_ID: 'gemini-3-pro-image-preview',
    ANALYSIS_ENDPOINT: '/v1beta/models/{model}:generateContent',
    GENERATION_ENDPOINT: '/v1beta/models/{model}:generateContent',
    API_KEY: '',
    IMAGE_UPLOAD_ENDPOINT: ''
  };

  // 如果项目下没有配置文件，返回默认配置
  if (!fs.existsSync(configPath)) {
    console.warn('警告: 未找到配置文件 config/secrets.md，使用默认配置');
    console.warn('提示: 如果需要自定义配置，请创建 config/secrets.md 文件');
    console.warn('');
    return defaultConfig;
  }

  // 读取项目配置
  try {
    const configContent = fs.readFileSync(configPath, 'utf8');
    const config = Object.assign({}, defaultConfig);

    configContent.split('\n').forEach(line => {
      const match = line.match(/^([A-Z_]+)=(.+)$/);
      if (match) {
        (config as any)[match[1]] = match[2];
      }
    });

    return config;

  } catch (error: any) {
    console.warn('警告: 读取配置文件失败，使用默认配置:', error.message);
    return defaultConfig;
  }
}

// 构建完整的 API URL
function buildApiUrl(config: Config, endpointTemplate: string, modelId: string): string {
  const endpoint = endpointTemplate.replace('{model}', modelId);
  return `${config.API_BASE_URL}${endpoint}`;
}

// 下载图像
function downloadImage(url: string, outputPath: string): Promise<string> {
  return new Promise((resolve, reject) => {
    const protocol = url.startsWith('https') ? https : http;

    protocol.get(url, (response) => {
      if (response.statusCode !== 200) {
        reject(new Error(`下载失败: ${response.statusCode}`));
        return;
      }

      const chunks: Buffer[] = [];
      response.on('data', (chunk) => chunks.push(chunk));
      response.on('end', () => {
        const buffer = Buffer.concat(chunks);
        fs.writeFileSync(outputPath, buffer);
        resolve(outputPath);
      });
    }).on('error', reject);
  });
}

// 调用 API 分析图像
async function analyzeImage(imagePath: string, config: Config): Promise<string> {

  // 读取图像并转换为 base64
  const imageBuffer = fs.readFileSync(imagePath);
  const base64Image = imageBuffer.toString('base64');

  const apiUrl = buildApiUrl(config, config.ANALYSIS_ENDPOINT, config.ANALYSIS_MODEL_ID);

  const requestBody = {
    contents: [
      {
        role: "user",
        parts: [
          {
            inlineData: {
              mime_type: "image/png",
              data: base64Image
            }
          },
          {
            text: `请详细分析这张图片的艺术风格和特征，包括：
1. 艺术风格（如水彩、油画、动漫等）
2. 色彩方案（主色调、色彩搭配）
3. 构图方式（如三分法、对称构图等）
4. 光照和氛围
5. 笔触和纹理特征
6. 整体感觉和情绪

请用简洁的中文描述，每个要点不超过两句话。`
          }
        ]
      }
    ]
  };

  const response = await fetch(apiUrl, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${config.API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(requestBody)
  });

  const data = await response.json();

  if (data.candidates && data.candidates.length > 0) {
    const parts = data.candidates[0].content?.parts || [];
    for (const part of parts) {
      if (part.text) {
        return part.text;
      }
    }
  }

  throw new Error('无法获取分析结果');
}

// 主函数
async function main() {
  const imageUrl = process.argv[2];
  const outputDir = process.argv[3] || path.join(process.cwd(), 'output');

  if (!imageUrl) {
    console.error('使用方法: npx -y bun ${SKILL_DIR}/scripts/analyze-image.ts <图像URL或路径> [输出目录]');
    console.error('');
    console.error('示例:');
    console.error('  npx -y bun ${SKILL_DIR}/scripts/analyze-image.ts https://example.com/image.png');
    console.error('  npx -y bun ${SKILL_DIR}/scripts/analyze-image.ts ./local-image.png ./output');
    process.exit(1);
  }

  try {
    // 加载配置
    console.log('加载配置...');
    const config = loadConfig();

    // 创建输出目录
    fs.mkdirSync(outputDir, { recursive: true });

    // 下载或读取图像
    console.log('读取图像...');
    let localImagePath: string;
    let isLocal = !imageUrl.startsWith('http');

    if (!isLocal) {
      const filename = path.basename(imageUrl).split('?')[0] || 'image.png';
      localImagePath = path.join(outputDir, 'config.example', '_temp_download.png');
      fs.mkdirSync(path.dirname(localImagePath), { recursive: true });
      console.log('下载图像到:', localImagePath);
      await downloadImage(imageUrl, localImagePath);
    } else {
      localImagePath = imageUrl;
      // 复制到 config.example 目录
      const refPath = path.join(outputDir, 'config.example', path.basename(imageUrl));
      fs.mkdirSync(path.dirname(refPath), { recursive: true });
      fs.copyFileSync(imageUrl, refPath);
      localImagePath = refPath;
    }

    // 分析图像
    console.log('分析图像风格...');
    const analysis = await analyzeImage(localImagePath, config);

    // 保存分析结果
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
    const outputFile = path.join(outputDir, 'analysis', `01_图像风格分析_${timestamp}.md`);
    fs.mkdirSync(path.dirname(outputFile), { recursive: true });

    // 计算相对路径
    const relativeImagePath = path.relative(path.dirname(outputFile), localImagePath);

    fs.writeFileSync(outputFile, `# 图像风格分析

生成时间: ${new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })}
原始图像: ${isLocal ? path.basename(imageUrl) : imageUrl}

## 风格分析

${analysis}

## 参考图像

![参考图像](${relativeImagePath})
`);

    console.log('分析完成!');
    console.log('结果保存到:', outputFile);
    console.log('参考图像保存在:', path.join(outputDir, 'config.example', path.basename(imageUrl)));

  } catch (error: any) {
    console.error('错误:', error.message);
    process.exit(1);
  }
}

main();

#!/usr/bin/env bun

/**
 * delete-image.ts - 删除图床上的图片
 *
 * 用法:
 *   npx -y bun ${SKILL_DIR}/scripts/delete-image.ts list              # 列出所有上传的图片
 *   npx -y bun ${SKILL_DIR}/scripts/delete-image.ts delete <index>    # 删除指定索引的图片
 *   npx -y bun ${SKILL_DIR}/scripts/delete-image.ts delete-all        # 删除所有图片
 */

import fs from 'fs';
import path from 'path';

// 历史记录类型
interface HistoryEntry {
  timestamp: string;
  file: string;
  url: string;
  deleteUrl: string | null;
  deleteHash: string | null;
  provider: string;
}

const historyFile = path.join(process.cwd(), '.upload-history.json');

// 读取上传历史
function loadHistory(): HistoryEntry[] {
  if (fs.existsSync(historyFile)) {
    try {
      return JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
    } catch (err: any) {
      console.error('读取历史记录失败:', err.message);
      return [];
    }
  }
  return [];
}

// 保存上传历史
function saveHistory(history: HistoryEntry[]): void {
  fs.writeFileSync(historyFile, JSON.stringify(history, null, 2), 'utf-8');
}

// 列出所有图片
function listImages(): void {
  const history = loadHistory();

  if (history.length === 0) {
    console.log('没有上传历史记录');
    console.log(`\n历史记录文件: ${historyFile}`);
    return;
  }

  console.log(`\n上传历史 (共 ${history.length} 张):\n`);
  history.forEach((item, index) => {
    const date = new Date(item.timestamp).toLocaleString('zh-CN');
    console.log(`[${index}] ${item.file}`);
    console.log(`    上传时间: ${date}`);
    console.log(`    图床: ${item.provider || '未知'}`);
    console.log(`    图片 URL: ${item.url}`);
    console.log(`    删除链接: ${item.deleteUrl || '无'}`);
    console.log('');
  });

  console.log(`历史记录文件: ${historyFile}`);
  console.log(`\n💡 提示: 访问删除链接在浏览器中手动删除图片`);
}

// 删除指定图片
function deleteByIndex(index: number): void {
  const history = loadHistory();

  if (index < 0 || index >= history.length) {
    console.error(`错误: 索引 ${index} 超出范围 (0-${history.length - 1})`);
    process.exit(1);
  }

  const item = history[index];

  if (!item.deleteUrl) {
    console.error('错误: 该图片没有删除链接');
    process.exit(1);
  }

  console.log(`准备从历史记录中移除: ${item.file}`);
  console.log(`图床: ${item.provider || '未知'}`);
  console.log(`图片 URL: ${item.url}`);
  console.log(`删除链接: ${item.deleteUrl}`);
  console.log(`\n⚠️  请手动访问删除链接删除图片`);

  // 从历史记录中移除
  history.splice(index, 1);
  saveHistory(history);
  console.log('✅ 已从历史记录中移除');
}

// 删除所有图片
function deleteAll(): void {
  const history = loadHistory();

  if (history.length === 0) {
    console.log('没有需要删除的图片');
    return;
  }

  console.log(`准备从历史记录中移除 ${history.length} 张图片...\n`);

  history.forEach((item, index) => {
    console.log(`[${index}] ${item.file}`);
    console.log(`    图床: ${item.provider || '未知'}`);
    console.log(`    删除链接: ${item.deleteUrl || '无'}`);
  });

  console.log(`\n⚠️  请手动访问删除链接删除图片`);
  console.log(`\n清空历史记录...`);

  saveHistory([]);
  console.log(`✅ 已清空历史记录 (${history.length} 条)`);
}

// 主函数
const args = process.argv.slice(2);

if (args.length === 0) {
  console.log('用法:');
  console.log('  npx -y bun ${SKILL_DIR}/scripts/delete-image.ts list              # 列出所有上传的图片');
  console.log('  npx -y bun ${SKILL_DIR}/scripts/delete-image.ts delete <index>    # 删除指定索引的图片');
  console.log('  npx -y bun ${SKILL_DIR}/scripts/delete-image.ts delete-all        # 删除所有图片');
  process.exit(1);
}

const command = args[0];

switch (command) {
  case 'list':
    listImages();
    break;

  case 'delete':
    if (args.length < 2) {
      console.error('错误: 请指定要删除的图片索引');
      console.log('用法: npx -y bun ${SKILL_DIR}/scripts/delete-image.ts delete <index>');
      process.exit(1);
    }
    const index = parseInt(args[1]);
    if (isNaN(index)) {
      console.error('错误: 索引必须是数字');
      process.exit(1);
    }
    deleteByIndex(index);
    break;

  case 'delete-all':
    deleteAll();
    break;

  default:
    console.error(`错误: 未知命令 "${command}"`);
    console.log('支持的命令: list, delete, delete-all');
    process.exit(1);
}

#!/usr/bin/env bun

/**
 * 生成图像脚本
 *
 * 使用方法：
 * npx -y bun ${SKILL_DIR}/scripts/generate-image.ts [输出目录]
 *
 * 输出目录结构：
 * images/                # 生成的图像 (默认)
 * prompts/               # 提示词文件
 * analysis/              # 图像风格分析
 */

import fs from 'fs';
import path from 'path';
import readline from 'readline';

// 配置类型定义
interface Config {
  API_BASE_URL: string;
  ANALYSIS_MODEL_ID: string;
  GENERATION_MODEL_ID: string;
  ANALYSIS_ENDPOINT: string;
  GENERATION_ENDPOINT: string;
  API_KEY: string;
  IMAGE_UPLOAD_ENDPOINT: string;
}

// 提示词文件类型
interface PromptFile {
  file: string;
  prompt: string;
  content: string;
}

// 创建 readline 接口用于用户交互
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// 读取配置（支持默认配置）
function loadConfig(): Config {
  const projectConfigPath = path.join(process.cwd(), 'config', 'secrets.md');
  const globalConfigPath = path.join(process.env.HOME || '', '.claude', 'skills', 'pw-image-generation', 'config', 'secrets.md');

  const defaultConfig: Config = {
    API_BASE_URL: 'https://ai-router.plugins-world.cn',
    ANALYSIS_MODEL_ID: 'gemini-2.0-flash-exp',
    GENERATION_MODEL_ID: 'gemini-3-pro-image-preview',
    ANALYSIS_ENDPOINT: '/v1beta/models/{model}:generateContent',
    GENERATION_ENDPOINT: '/v1beta/models/{model}:generateContent',
    API_KEY: '',
    IMAGE_UPLOAD_ENDPOINT: ''
  };

  // 优先使用项目配置,其次全局配置,最后默认配置
  let configPath: string | null = null;
  if (fs.existsSync(projectConfigPath)) {
    configPath = projectConfigPath;
    console.log('使用项目配置:', projectConfigPath);
  } else if (fs.existsSync(globalConfigPath)) {
    configPath = globalConfigPath;
    console.log('使用全局配置:', globalConfigPath);
  } else {
    console.warn('警告: 未找到配置文件，使用默认配置');
    console.warn('提示: 可以创建以下任一配置文件:');
    console.warn('  项目配置: config/secrets.md');
    console.warn('  全局配置:', globalConfigPath);
    console.warn('');
    return defaultConfig;
  }

  // 读取配置
  try {
    const configContent = fs.readFileSync(configPath, 'utf8');
    const config = Object.assign({}, defaultConfig);

    configContent.split('\n').forEach(line => {
      const match = line.match(/^([A-Z_]+)=(.+)$/);
      if (match) {
        (config as any)[match[1]] = match[2];
      }
    });

    return config;

  } catch (error: any) {
    console.warn('警告: 读取配置文件失败，使用默认配置:', error.message);
    return defaultConfig;
  }
}

// 构建完整的 API URL
function buildApiUrl(config: Config, endpointTemplate: string, modelId: string): string {
  const endpoint = endpointTemplate.replace('{model}', modelId);
  return `${config.API_BASE_URL}${endpoint}`;
}

// 用户确认
function askUser(question: string): Promise<string> {
  return new Promise((resolve) => {
    rl.question(question, (answer) => {
      resolve(answer.trim().toLowerCase());
    });
  });
}

// 调用 API 生成图像
async function generateImage(prompt: string, referenceImagePath: string | null, config: Config): Promise<Buffer> {
  const requestBody: any = {
    contents: [
      {
        role: "user",
        parts: []
      }
    ],
    generationConfig: {
      responseModalities: ["TEXT", "IMAGE"]
    }
  };

  // 添加参考图片
  if (referenceImagePath && fs.existsSync(referenceImagePath)) {
    const imageBuffer = fs.readFileSync(referenceImagePath);
    const base64Image = imageBuffer.toString('base64');

    requestBody.contents[0].parts.push({
      inlineData: {
        mime_type: "image/png",
        data: base64Image
      }
    });
  }

  // 添加提示词
  requestBody.contents[0].parts.push({
    text: prompt
  });

  console.log('  调用 API...');
  const apiUrl = buildApiUrl(config, config.GENERATION_ENDPOINT, config.GENERATION_MODEL_ID);

  const response = await fetch(apiUrl, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${config.API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(requestBody)
  });

  const data = await response.json();

  // 调试：打印响应数据
  console.log('  API 响应状态:', response.status);
  if (!response.ok) {
    console.log('  错误响应:', JSON.stringify(data, null, 2).substring(0, 500));
    throw new Error(`API 请求失败: ${response.status}`);
  }

  // 提取图像数据
  if (data.candidates && data.candidates.length > 0) {
    const parts = data.candidates[0].content?.parts || [];
    for (const part of parts) {
      if (part.inlineData) {
        return Buffer.from(part.inlineData.data, 'base64');
      }
    }
  }

  // 调试：打印响应结构
  console.log('  响应结构:', JSON.stringify(data, null, 2).substring(0, 500));
  throw new Error('无法获取图像数据');
}

// 读取风格分析文件
function readStyleAnalysis(outputDir: string): string | null {
  const analysisDir = path.join(outputDir, 'analysis');
  if (!fs.existsSync(analysisDir)) {
    return null;
  }

  const files = fs.readdirSync(analysisDir);
  const styleFile = files.find(f => f.startsWith('01_图像风格分析'));

  if (!styleFile) {
    return null;
  }

  const content = fs.readFileSync(path.join(analysisDir, styleFile), 'utf8');
  return content;
}

// 读取提示词文件
function readPromptFiles(outputDir: string): PromptFile[] {
  // 优先从当前目录的 prompts/ 查找
  let promptsDir = path.join(process.cwd(), 'prompts');

  // 如果不存在，尝试从 outputDir 的父目录查找
  if (!fs.existsSync(promptsDir) && outputDir) {
    const parentDir = path.dirname(outputDir);
    promptsDir = path.join(parentDir, 'prompts');
  }

  if (!fs.existsSync(promptsDir)) {
    return [];
  }

  const files = fs.readdirSync(promptsDir);
  const promptFiles = files.filter(f => f.endsWith('.md'));

  return promptFiles.map(file => {
    const content = fs.readFileSync(path.join(promptsDir, file), 'utf8');

    // 尝试匹配多种格式:
    // 1. ## 提示词 或 ## 完整提示词 后跟代码块
    const codeBlockMatch = content.match(/##\s*(?:完整)?提示词\s*\n\s*```[^\n]*\n([\s\S]+?)```/);
    if (codeBlockMatch) {
      return {
        file,
        prompt: codeBlockMatch[1].trim(),
        content
      };
    }

    // 2. ## 提示词 后直接跟文本
    const directMatch = content.match(/##\s*提示词\s*\n\s*(.+?)(?:\n\n|$)/s);
    if (directMatch) {
      return {
        file,
        prompt: directMatch[1].trim(),
        content
      };
    }

    // 3. 兜底: 使用整个文件内容
    return {
      file,
      prompt: content,
      content
    };
  });
}

// 主函数
async function main() {
  const outputDir = process.argv[2] || path.join(process.cwd(), 'images');

  if (!fs.existsSync(outputDir)) {
    console.warn('警告: 输出目录不存在，将创建:', outputDir);
    fs.mkdirSync(outputDir, { recursive: true });
  }

  try {
    // 加载配置
    console.log('加载配置...');
    const config = loadConfig();

    // 图片直接保存在输出目录
    const imagesDir = outputDir;

    // 读取风格分析
    console.log('\n读取风格分析...');
    const styleAnalysis = readStyleAnalysis(outputDir);
    if (styleAnalysis) {
      console.log('  找到风格分析文件');
    } else {
      console.log('  未找到风格分析文件');
    }

    // 读取提示词文件
    console.log('\n读取提示词文件...');
    const prompts = readPromptFiles(outputDir);

    if (prompts.length === 0) {
      console.error('错误: 未找到提示词文件');
      console.error('');
      console.error('请先创建提示词文件，参考:');
      console.error('  ~/.claude/skills/pw-image-generation/references/prompt-templates/提示词模板.md');
      console.error('');
      console.error('提示词文件格式:');
      console.error('  ## 提示词');
      console.error('  ');
      console.error('  一只可爱的柴犬在樱花树下睡觉，水彩风格');
      process.exit(1);
    }

    console.log(`  找到 ${prompts.length} 个提示词文件\n`);

    // 询问生成模式
    console.log('请选择生成模式:');
    console.log('  1. 逐个确认 (每张图像生成前都会询问)');
    console.log('  2. 批量生成 (跳过确认，直接生成所有图像)');
    const modeChoice = await askUser('请输入选项 (1/2, 默认: 1): ');
    const batchMode = modeChoice === '2';

    if (batchMode) {
      console.log('\n【批量模式】将自动生成所有图像，跳过已存在的图像\n');
    } else {
      console.log('\n【逐个确认模式】每张图像生成前都会询问\n');
    }

    // 生成每张图像
    for (let i = 0; i < prompts.length; i++) {
      const { file, prompt, content } = prompts[i];

      console.log('='.repeat(60));
      console.log(`任务 ${i + 1}/${prompts.length}: ${file}`);
      console.log('='.repeat(60));
      console.log('\n提示词:');
      console.log(prompt);
      console.log('');

      // 检查是否已生成
      const imageFileName = file.replace('.md', '.png');
      const imagePath = path.join(imagesDir, imageFileName);

      if (fs.existsSync(imagePath)) {
        console.log(`图像已存在: ${imageFileName}`);
        if (batchMode) {
          console.log('批量模式: 自动跳过\n');
          continue;
        }
        const skip = await askUser('是否跳过已生成的图像? (y/n, 默认: y): ');
        if (skip !== 'n') {
          console.log('跳过\n');
          continue;
        }
      }

      // 用户确认（重点：避免额度浪费）
      if (!batchMode) {
        console.log('【重要提示】生成将消耗 API 额度');
        const confirm = await askUser('是否生成此图像? (y/n, 默认: y): ');
        if (confirm === 'n') {
          console.log('跳过\n');
          continue;
        }
      }

      // 检查是否有参考图像
      let referenceImagePath: string | null = null;
      const refMatch = content.match(/参考图像:\s*\[!\[.*?\]\((.+?)\)\]/);
      if (refMatch) {
        const relativeRefPath = refMatch[1];
        referenceImagePath = path.resolve(path.join(outputDir, 'analysis', relativeRefPath));
        if (fs.existsSync(referenceImagePath)) {
          console.log('\n使用参考图像:', path.basename(referenceImagePath));
        } else {
          referenceImagePath = null;
        }
      }

      // 生成图像
      console.log('\n开始生成图像...');
      const startTime = Date.now();

      try {
        const imageData = await generateImage(prompt, referenceImagePath, config);

        // 保存图像
        fs.writeFileSync(imagePath, imageData);
        const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
        console.log(`\n✓ 图像生成成功! (${elapsed}秒)`);
        console.log(`  保存到: ${imagePath}\n`);

      } catch (error: any) {
        console.error('\n✗ 图像生成失败:', error.message);
        const retry = await askUser('是否重试? (y/n, 默认: n): ');
        if (retry === 'y') {
          i--; // 重试当前任务
        }
        console.log('');
      }
    }

    console.log('='.repeat(60));
    console.log('所有任务完成!');
    console.log('='.repeat(60));
    console.log(`\n生成的图像保存在: ${imagesDir}\n`);

  } catch (error: any) {
    console.error('\n错误:', error.message);
    process.exit(1);
  } finally {
    rl.close();
  }
}

main();

#!/usr/bin/env bun

/**
 * 图片合并为长图脚本
 *
 * 使用方法：
 * npx -y bun ${SKILL_DIR}/scripts/merge-to-long-image.ts <图片目录> <输出文件>
 *
 * 示例：
 * npx -y bun ${SKILL_DIR}/scripts/merge-to-long-image.ts ./images output.png
 */

import fs from 'fs';
import path from 'path';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

// 支持的图片格式
const IMAGE_EXTENSIONS = ['.jpg', '.jpeg', '.png', '.gif', '.webp'];

// 读取目录下的所有图片
function getImageFiles(dir: string): string[] {
  const files = fs.readdirSync(dir);

  return files
    .filter(file => {
      const ext = path.extname(file).toLowerCase();
      return IMAGE_EXTENSIONS.includes(ext);
    })
    .sort((a, b) => {
      // 按文件名中的数字排序
      const numA = parseInt(a.match(/\d+/)?.[0] || '0');
      const numB = parseInt(b.match(/\d+/)?.[0] || '0');
      return numA - numB;
    })
    .map(file => path.join(dir, file));
}

// 使用 ImageMagick 合并图片
async function mergeImagesWithImageMagick(imageFiles: string[], outputFile: string): Promise<boolean> {
  const command = `convert ${imageFiles.map(f => `"${f}"`).join(' ')} -append "${outputFile}"`;

  try {
    await execAsync(command);
    return true;
  } catch (error) {
    return false;
  }
}

// 主函数
async function main() {
  const args = process.argv.slice(2);

  if (args.length < 2) {
    console.error('用法: npx -y bun ${SKILL_DIR}/scripts/merge-to-long-image.ts <图片目录> <输出文件>');
    console.error('');
    console.error('示例:');
    console.error('  npx -y bun ${SKILL_DIR}/scripts/merge-to-long-image.ts ./images output.png');
    process.exit(1);
  }

  const [imageDir, outputFile] = args;

  // 检查目录是否存在
  if (!fs.existsSync(imageDir)) {
    console.error(`错误: 目录不存在: ${imageDir}`);
    process.exit(1);
  }

  // 读取图片文件
  const imageFiles = getImageFiles(imageDir);

  if (imageFiles.length === 0) {
    console.error(`错误: 目录中没有找到图片文件: ${imageDir}`);
    process.exit(1);
  }

  console.log(`找到 ${imageFiles.length} 张图片:`);
  imageFiles.forEach((file, index) => {
    console.log(`  ${index + 1}. ${path.basename(file)}`);
  });
  console.log('');

  // 尝试使用 ImageMagick
  console.log('正在合并图片...');
  const success = await mergeImagesWithImageMagick(imageFiles, outputFile);

  if (success) {
    console.log(`✅ 长图生成成功: ${outputFile}`);
  } else {
    console.error('❌ 合并失败');
    console.error('');
    console.error('请确保已安装 ImageMagick:');
    console.error('  brew install imagemagick');
    process.exit(1);
  }
}

main().catch(error => {
  console.error('错误:', error.message);
  process.exit(1);
});

#!/usr/bin/env bun

/**
 * images2pptx.ts - 将图片文件夹打包成 PPT
 *
 * 用法: npx -y bun ${SKILL_DIR}/scripts/merge-to-pptx.ts <图片目录> [输出文件名]
 * 示例: npx -y bun ${SKILL_DIR}/scripts/merge-to-pptx.ts ./slides output.pptx
 */

import pptxgen from 'pptxgenjs';
import fs from 'fs';
import path from 'path';

// 参数解析
const args = process.argv.slice(2);
if (args.length < 1) {
  console.log('用法: npx -y bun ${SKILL_DIR}/scripts/merge-to-pptx.ts <图片目录> [输出文件名]');
  console.log('示例: npx -y bun ${SKILL_DIR}/scripts/merge-to-pptx.ts ./slides output.pptx');
  process.exit(1);
}

const inputDir = path.resolve(args[0]);
const outputFile = args[1] || 'output.pptx';
const outputPath = path.resolve(inputDir, outputFile);

// 检查目录
if (!fs.existsSync(inputDir)) {
  console.error(`错误: 目录不存在 - ${inputDir}`);
  process.exit(1);
}

// 获取图片文件
const imageExts = ['.jpg', '.jpeg', '.png', '.gif', '.webp'];
const images = fs.readdirSync(inputDir)
  .filter(f => imageExts.includes(path.extname(f).toLowerCase()))
  .sort((a, b) => {
    // 尝试按数字排序（支持 "第1页", "slide1", "1" 等格式）
    const numA = parseInt(a.match(/\d+/)?.[0] || '0');
    const numB = parseInt(b.match(/\d+/)?.[0] || '0');
    if (numA !== numB) return numA - numB;
    return a.localeCompare(b, 'zh-CN');
  });

if (images.length === 0) {
  console.error('错误: 目录中没有找到图片文件');
  process.exit(1);
}

console.log(`找到 ${images.length} 张图片:`);
images.forEach((img, i) => console.log(`  ${i + 1}. ${img}`));

// 创建 PPT
const pptx = new pptxgen();
pptx.layout = 'LAYOUT_16x9';
pptx.title = path.basename(inputDir);

images.forEach((filename) => {
  const slide = pptx.addSlide();
  slide.addImage({
    path: path.join(inputDir, filename),
    x: 0,
    y: 0,
    w: '100%',
    h: '100%'
  });
});

// 保存
pptx.writeFile({ fileName: outputPath })
  .then(() => {
    console.log(`\n✅ PPT 生成成功: ${outputPath}`);
    console.log(`   共 ${images.length} 页`);
  })
  .catch((err: any) => {
    console.error('生成失败:', err);
    process.exit(1);
  });

#!/usr/bin/env bun

/**
 * upload-image.ts - 上传图片到图床获取 URL
 *
 * 用法: npx -y bun ${SKILL_DIR}/scripts/upload-image.ts <图片路径>
 * 示例: npx -y bun ${SKILL_DIR}/scripts/upload-image.ts ./template/图.001.png
 */

import fs from 'fs';
import path from 'path';
import { execSync } from 'child_process';

// 上传结果类型
interface UploadResult {
  success: boolean;
  url?: string;
  deleteUrl?: string | null;
  deleteHash?: string | null;
  provider?: string;
  error?: string;
  note?: string;
}

// 历史记录类型
interface HistoryEntry {
  timestamp: string;
  file: string;
  url: string;
  deleteUrl: string | null;
  deleteHash: string | null;
  provider: string;
}

// 参数解析
const args = process.argv.slice(2);
if (args.length < 1) {
  console.log('用法: npx -y bun ${SKILL_DIR}/scripts/upload-image.ts <图片路径>');
  console.log('示例: npx -y bun ${SKILL_DIR}/scripts/upload-image.ts ./template/图.001.png');
  process.exit(1);
}

const imagePath = path.resolve(args[0]);
const historyFile = path.join(process.cwd(), '.upload-history.json');

// 检查文件
if (!fs.existsSync(imagePath)) {
  console.error(`错误: 文件不存在 - ${imagePath}`);
  process.exit(1);
}

// 读取上传历史
function loadHistory(): HistoryEntry[] {
  if (fs.existsSync(historyFile)) {
    try {
      return JSON.parse(fs.readFileSync(historyFile, 'utf-8'));
    } catch (err) {
      return [];
    }
  }
  return [];
}

// 保存上传历史
function saveHistory(history: HistoryEntry[]): void {
  fs.writeFileSync(historyFile, JSON.stringify(history, null, 2), 'utf-8');
}

// 上传到 sm.ms
function uploadToSmMs(imagePath: string): UploadResult {
  console.log('尝试上传到 sm.ms...');
  try {
    const cmd = `curl -s -X POST -F "smfile=@${imagePath}" https://sm.ms/api/v2/upload`;
    const result = execSync(cmd, { encoding: 'utf-8' });
    const json = JSON.parse(result);

    if (json.success && json.data && json.data.url) {
      return {
        success: true,
        url: json.data.url,
        deleteHash: json.data.hash || null,
        deleteUrl: json.data.delete ? `https://sm.ms/delete/${json.data.hash}` : null,
        provider: 'sm.ms'
      };
    } else if (json.code === 'image_repeated' && json.images) {
      // 图片已存在，返回已有的 URL
      return {
        success: true,
        url: json.images,
        deleteHash: null,
        deleteUrl: null,
        provider: 'sm.ms',
        note: '图片已存在'
      };
    } else {
      return { success: false, error: json.message || '未知错误' };
    }
  } catch (err: any) {
    return { success: false, error: err.message };
  }
}

// 上传到 freeimage.host
function uploadToFreeimage(imagePath: string): UploadResult {
  console.log('尝试上传到 freeimage.host...');
  try {
    const cmd = `curl -s -X POST -F "source=@${imagePath}" "https://freeimage.host/api/1/upload?key=6d207e02198a847aa98d0a2a901485a5"`;
    const result = execSync(cmd, { encoding: 'utf-8' });
    const json = JSON.parse(result);

    if (json.status_code === 200 && json.image && json.image.url) {
      return {
        success: true,
        url: json.image.url,
        deleteUrl: json.image.url_viewer || null,
        provider: 'freeimage.host'
      };
    } else {
      return { success: false, error: json.error || '未知错误' };
    }
  } catch (err: any) {
    return { success: false, error: err.message };
  }
}

// 主逻辑：优先 sm.ms，失败则尝试 freeimage.host
console.log(`正在上传: ${imagePath}`);

let result = uploadToSmMs(imagePath);

if (!result.success) {
  console.log(`sm.ms 上传失败: ${result.error}`);
  result = uploadToFreeimage(imagePath);
}

if (result.success && result.url) {
  console.log(`\n✅ 上传成功 (${result.provider}): ${result.url}`);
  if (result.note) {
    console.log(`   注意: ${result.note}`);
  }
  console.log(`\n可以在提示词中使用:\n${result.url} 参考这张图片...`);

  // 保存到历史记录
  const history = loadHistory();
  history.push({
    timestamp: new Date().toISOString(),
    file: path.basename(imagePath),
    url: result.url,
    deleteUrl: result.deleteUrl || null,
    deleteHash: result.deleteHash || null,
    provider: result.provider || 'unknown'
  });
  saveHistory(history);

  console.log(`\n📝 删除链接已保存到: ${historyFile}`);
  if (result.deleteUrl) {
    console.log(`   删除链接: ${result.deleteUrl}`);
  }
  if (result.deleteHash) {
    console.log(`   删除 Hash: ${result.deleteHash}`);
  }
  console.log(`\n💡 提示: 使用 delete-image.ts 可以批量删除图片`);
} else {
  console.error(`\n❌ 所有图床上传失败`);
  console.error(`   最后错误: ${result.error}`);
  process.exit(1);
}