myaidev-method 0.2.12 → 0.2.15

package/src/lib/asset-management.js

@@ -0,0 +1,532 @@
+/**
+ * Asset Management Utilities
+ *
+ * Handles file storage, organization, and tracking for generated visual content.
+ * Supports images and videos with automatic directory organization by date.
+ *
+ * Platform support: Claude Code, Gemini CLI, Codex CLI
+ *
+ * @module asset-management
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+// Default asset storage path
+const DEFAULT_ASSETS_PATH = './content-assets';
+
+// Usage tracking file
+const USAGE_STATS_FILE = '.visual-usage-stats.json';
+
+/**
+ * Get configured assets path from environment or use default
+ *
+ * @returns {string} Assets directory path
+ */
+export function getAssetsPath() {
+  return process.env.VISUAL_ASSETS_PATH || DEFAULT_ASSETS_PATH;
+}
+
+/**
+ * Create asset directory structure for a specific date
+ * Creates: content-assets/images/YYYY-MM-DD/ and content-assets/videos/YYYY-MM-DD/
+ *
+ * @param {Date} date - Date for directory organization (defaults to today)
+ * @returns {Promise<Object>} Created directory paths
+ */
+export async function createAssetDirectory(date = new Date()) {
+  const assetsPath = getAssetsPath();
+  const dateStr = formatDate(date);
+
+  const imagePath = path.join(assetsPath, 'images', dateStr);
+  const videoPath = path.join(assetsPath, 'videos', dateStr);
+
+  await fs.ensureDir(imagePath);
+  await fs.ensureDir(videoPath);
+
+  return {
+    images: imagePath,
+    videos: videoPath,
+    date: dateStr
+  };
+}
+
+/**
+ * Generate filename for asset based on type and description
+ *
+ * @param {string} type - Asset type (hero, illustration, diagram, screenshot, video)
+ * @param {string} slug - Descriptive slug (will be sanitized)
+ * @param {string} extension - File extension (png, jpg, mp4, etc.)
+ * @returns {string} Generated filename
+ */
+export function generateFilename(type, slug, extension = 'png') {
+  // Sanitize slug: lowercase, replace spaces/special chars with hyphens
+  const sanitized = slug
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .substring(0, 50); // Max 50 chars
+
+  const timestamp = Date.now().toString().slice(-6); // Last 6 digits for uniqueness
+
+  return `${type}-${sanitized}-${timestamp}.${extension}`;
+}
+
+/**
+ * Save image to content-assets directory
+ *
+ * @param {Buffer} buffer - Image data buffer
+ * @param {Object} metadata - Image metadata
+ * @param {string} metadata.type - Image type (hero, illustration, diagram, screenshot)
+ * @param {string} metadata.description - Image description for filename
+ * @param {string} metadata.service - Service used (gemini, imagen, dalle)
+ * @param {number} metadata.cost - Generation cost
+ * @param {string} metadata.prompt - Original prompt
+ * @param {Date} metadata.date - Creation date (defaults to now)
+ * @returns {Promise<Object>} Saved file information
+ */
+export async function saveImage(buffer, metadata) {
+  const {
+    type = 'general',
+    description,
+    service,
+    cost = 0,
+    prompt,
+    date = new Date()
+  } = metadata;
+
+  // Create directory structure
+  const dirs = await createAssetDirectory(date);
+
+  // Generate filename
+  const filename = generateFilename(type, description, 'png');
+  const filepath = path.join(dirs.images, filename);
+
+  // Save image
+  await fs.writeFile(filepath, buffer);
+
+  // Track usage
+  await trackCost(service, cost, {
+    type: 'image',
+    filename,
+    prompt,
+    date
+  });
+
+  const relativePath = path.relative(process.cwd(), filepath);
+
+  return {
+    filepath,
+    relativePath,
+    filename,
+    type,
+    service,
+    cost,
+    size: buffer.length,
+    date: date.toISOString()
+  };
+}
+
+/**
+ * Save video to content-assets directory
+ *
+ * @param {Buffer} buffer - Video data buffer
+ * @param {Object} metadata - Video metadata
+ * @param {string} metadata.description - Video description for filename
+ * @param {string} metadata.service - Service used (veo)
+ * @param {number} metadata.cost - Generation cost
+ * @param {string} metadata.prompt - Original prompt
+ * @param {number} metadata.duration - Video duration in seconds
+ * @param {Date} metadata.date - Creation date (defaults to now)
+ * @returns {Promise<Object>} Saved file information
+ */
+export async function saveVideo(buffer, metadata) {
+  const {
+    description,
+    service,
+    cost = 0,
+    prompt,
+    duration = 0,
+    date = new Date()
+  } = metadata;
+
+  // Create directory structure
+  const dirs = await createAssetDirectory(date);
+
+  // Generate filename
+  const filename = generateFilename('video', description, 'mp4');
+  const filepath = path.join(dirs.videos, filename);
+
+  // Save video
+  await fs.writeFile(filepath, buffer);
+
+  // Track usage
+  await trackCost(service, cost, {
+    type: 'video',
+    filename,
+    prompt,
+    duration,
+    date
+  });
+
+  const relativePath = path.relative(process.cwd(), filepath);
+
+  return {
+    filepath,
+    relativePath,
+    filename,
+    service,
+    cost,
+    duration,
+    size: buffer.length,
+    date: date.toISOString()
+  };
+}
+
+/**
+ * Generate markdown reference for image
+ *
+ * @param {string} filepath - Relative or absolute file path
+ * @param {string} altText - Alt text for accessibility
+ * @param {string} caption - Optional caption
+ * @returns {string} Markdown image reference
+ */
+export function generateMarkdownReference(filepath, altText, caption = null) {
+  // Convert to relative path if absolute
+  const relativePath = filepath.startsWith('./') || filepath.startsWith('../')
+    ? filepath
+    : `./${filepath}`;
+
+  let markdown = `![${altText}](${relativePath})`;
+
+  if (caption) {
+    markdown += `\n*${caption}*`;
+  }
+
+  return markdown;
+}
+
+/**
+ * Track cost and usage statistics
+ *
+ * @param {string} service - Service name
+ * @param {number} cost - Cost in USD
+ * @param {Object} metadata - Additional metadata to track
+ * @returns {Promise<void>}
+ */
+export async function trackCost(service, cost, metadata = {}) {
+  const statsPath = path.join(process.cwd(), USAGE_STATS_FILE);
+
+  // Load existing stats
+  let stats = {
+    totalCost: 0,
+    daily: {},
+    monthly: {},
+    byService: {},
+    history: []
+  };
+
+  if (await fs.pathExists(statsPath)) {
+    stats = await fs.readJSON(statsPath);
+  }
+
+  // Get date keys
+  const now = new Date();
+  const dateKey = formatDate(now);
+  const monthKey = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+
+  // Update totals
+  stats.totalCost += cost;
+
+  // Update daily
+  stats.daily[dateKey] = (stats.daily[dateKey] || 0) + cost;
+
+  // Update monthly
+  stats.monthly[monthKey] = (stats.monthly[monthKey] || 0) + cost;
+
+  // Update by service
+  if (!stats.byService[service]) {
+    stats.byService[service] = { count: 0, cost: 0 };
+  }
+  stats.byService[service].count += 1;
+  stats.byService[service].cost += cost;
+
+  // Add to history
+  stats.history.push({
+    service,
+    cost,
+    date: now.toISOString(),
+    ...metadata
+  });
+
+  // Keep only last 1000 history entries
+  if (stats.history.length > 1000) {
+    stats.history = stats.history.slice(-1000);
+  }
+
+  // Save stats
+  await fs.writeJSON(statsPath, stats, { spaces: 2 });
+}
+
+/**
+ * Get usage statistics
+ *
+ * @returns {Promise<Object>} Usage statistics
+ */
+export async function getUsageStats() {
+  const statsPath = path.join(process.cwd(), USAGE_STATS_FILE);
+
+  if (!await fs.pathExists(statsPath)) {
+    return {
+      totalCost: 0,
+      daily: {},
+      monthly: {},
+      byService: {},
+      history: []
+    };
+  }
+
+  return await fs.readJSON(statsPath);
+}
+
+/**
+ * Get today's usage cost
+ *
+ * @returns {Promise<number>} Today's cost in USD
+ */
+export async function getTodaysCost() {
+  const stats = await getUsageStats();
+  const today = formatDate(new Date());
+  return stats.daily[today] || 0;
+}
+
+/**
+ * Get this month's usage cost
+ *
+ * @returns {Promise<number>} This month's cost in USD
+ */
+export async function getMonthCost() {
+  const stats = await getUsageStats();
+  const now = new Date();
+  const monthKey = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+  return stats.monthly[monthKey] || 0;
+}
+
+/**
+ * Check if cost exceeds budget limits
+ *
+ * @param {number} estimatedCost - Estimated cost for next operation
+ * @returns {Promise<Object>} Budget check result
+ */
+export async function checkBudgetLimit(estimatedCost) {
+  const dailyBudget = parseFloat(process.env.VISUAL_DAILY_BUDGET || 5.0);
+  const monthlyBudget = parseFloat(process.env.VISUAL_MONTHLY_BUDGET || 50.0);
+  const warnThreshold = parseFloat(process.env.VISUAL_WARN_THRESHOLD || 0.8);
+
+  const todaysCost = await getTodaysCost();
+  const monthCost = await getMonthCost();
+
+  const newDailyCost = todaysCost + estimatedCost;
+  const newMonthlyCost = monthCost + estimatedCost;
+
+  const result = {
+    dailyBudget,
+    monthlyBudget,
+    todaysCost,
+    monthCost,
+    newDailyCost,
+    newMonthlyCost,
+    estimatedCost,
+    exceedsDailyBudget: newDailyCost > dailyBudget,
+    exceedsMonthlyBudget: newMonthlyCost > monthlyBudget,
+    dailyWarning: newDailyCost > (dailyBudget * warnThreshold),
+    monthlyWarning: newMonthlyCost > (monthlyBudget * warnThreshold),
+    canProceed: newDailyCost <= dailyBudget && newMonthlyCost <= monthlyBudget
+  };
+
+  return result;
+}
+
+/**
+ * Generate usage report
+ *
+ * @param {string} period - Report period (today, week, month, all)
+ * @returns {Promise<string>} Formatted usage report
+ */
+export async function generateUsageReport(period = 'today') {
+  const stats = await getUsageStats();
+  const now = new Date();
+
+  let report = '📊 Visual Content Generation Usage Report\n\n';
+
+  // Daily budget info
+  const dailyBudget = parseFloat(process.env.VISUAL_DAILY_BUDGET || 5.0);
+  const monthlyBudget = parseFloat(process.env.VISUAL_MONTHLY_BUDGET || 50.0);
+  const todaysCost = await getTodaysCost();
+  const monthCost = await getMonthCost();
+
+  report += `💰 Budget Status:\n`;
+  report += `   Today: $${todaysCost.toFixed(2)} / $${dailyBudget.toFixed(2)} (${((todaysCost/dailyBudget)*100).toFixed(0)}%)\n`;
+  report += `   Month: $${monthCost.toFixed(2)} / $${monthlyBudget.toFixed(2)} (${((monthCost/monthlyBudget)*100).toFixed(0)}%)\n\n`;
+
+  // Service breakdown
+  report += `🎨 By Service:\n`;
+  for (const [service, data] of Object.entries(stats.byService)) {
+    report += `   ${service}: ${data.count} generations, $${data.cost.toFixed(2)}\n`;
+  }
+
+  report += `\n💵 Total Lifetime Cost: $${stats.totalCost.toFixed(2)}\n`;
+
+  return report;
+}
+
+/**
+ * Clean up old assets (optional maintenance)
+ *
+ * @param {number} daysOld - Delete assets older than this many days
+ * @returns {Promise<Object>} Cleanup results
+ */
+export async function cleanupOldAssets(daysOld = 30) {
+  const assetsPath = getAssetsPath();
+  const cutoffDate = new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - daysOld);
+
+  let deletedCount = 0;
+  let freedSpace = 0;
+
+  const imagePath = path.join(assetsPath, 'images');
+  const videoPath = path.join(assetsPath, 'videos');
+
+  // Clean images
+  if (await fs.pathExists(imagePath)) {
+    const dateDirs = await fs.readdir(imagePath);
+
+    for (const dateDir of dateDirs) {
+      const dirDate = new Date(dateDir);
+
+      if (dirDate < cutoffDate) {
+        const fullPath = path.join(imagePath, dateDir);
+        const files = await fs.readdir(fullPath);
+
+        for (const file of files) {
+          const filePath = path.join(fullPath, file);
+          const stats = await fs.stat(filePath);
+          freedSpace += stats.size;
+          deletedCount++;
+        }
+
+        await fs.remove(fullPath);
+      }
+    }
+  }
+
+  // Clean videos
+  if (await fs.pathExists(videoPath)) {
+    const dateDirs = await fs.readdir(videoPath);
+
+    for (const dateDir of dateDirs) {
+      const dirDate = new Date(dateDir);
+
+      if (dirDate < cutoffDate) {
+        const fullPath = path.join(videoPath, dateDir);
+        const files = await fs.readdir(fullPath);
+
+        for (const file of files) {
+          const filePath = path.join(fullPath, file);
+          const stats = await fs.stat(filePath);
+          freedSpace += stats.size;
+          deletedCount++;
+        }
+
+        await fs.remove(fullPath);
+      }
+    }
+  }
+
+  return {
+    deletedCount,
+    freedSpace,
+    freedSpaceMB: (freedSpace / 1024 / 1024).toFixed(2)
+  };
+}
+
+/**
+ * Format date as YYYY-MM-DD
+ *
+ * @param {Date} date - Date to format
+ * @returns {string} Formatted date string
+ */
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  return `${year}-${month}-${day}`;
+}
+
+/**
+ * List all generated assets
+ *
+ * @param {Object} options - Filter options
+ * @param {string} options.type - Filter by type (image, video)
+ * @param {string} options.date - Filter by date (YYYY-MM-DD)
+ * @param {number} options.limit - Limit results
+ * @returns {Promise<Array>} List of assets
+ */
+export async function listAssets(options = {}) {
+  const { type, date, limit } = options;
+  const assetsPath = getAssetsPath();
+  const assets = [];
+
+  // Determine which directories to scan
+  const dirs = [];
+  if (!type || type === 'image') {
+    dirs.push({ type: 'image', path: path.join(assetsPath, 'images') });
+  }
+  if (!type || type === 'video') {
+    dirs.push({ type: 'video', path: path.join(assetsPath, 'videos') });
+  }
+
+  // Scan directories
+  for (const dir of dirs) {
+    if (!await fs.pathExists(dir.path)) continue;
+
+    const dateDirs = await fs.readdir(dir.path);
+
+    for (const dateDir of dateDirs) {
+      // Filter by date if specified
+      if (date && dateDir !== date) continue;
+
+      const fullPath = path.join(dir.path, dateDir);
+      const files = await fs.readdir(fullPath);
+
+      for (const file of files) {
+        const filePath = path.join(fullPath, file);
+        const stats = await fs.stat(filePath);
+        const relativePath = path.relative(process.cwd(), filePath);
+
+        assets.push({
+          type: dir.type,
+          filename: file,
+          path: filePath,
+          relativePath,
+          date: dateDir,
+          size: stats.size,
+          created: stats.birthtime
+        });
+
+        // Check limit
+        if (limit && assets.length >= limit) {
+          return assets;
+        }
+      }
+    }
+  }
+
+  // Sort by created date (newest first)
+  assets.sort((a, b) => b.created - a.created);
+
+  return assets;
+}