@hienlh/ppm 0.9.79 → 0.9.81

package/.opencode/skills/content-hub/scripts/lib/ai-bridge.cjs

@@ -0,0 +1,165 @@
+/**
+ * AI Bridge - Connects Content Hub UI to Claude Code CLI
+ * Uses user's Claude Code subscription (no extra API cost)
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+/**
+ * Execute Claude Code CLI with prompt
+ * @param {string} prompt - The prompt to send
+ * @param {object} options - Options for execution
+ * @returns {Promise<object>} - Claude response
+ */
+function executeClaudeCode(prompt, options = {}) {
+  return new Promise((resolve, reject) => {
+    const {
+      outputFormat = 'json',
+      tools = 'Read,Edit,Write',
+      timeout = 120000, // 2 minutes
+      cwd = process.cwd()
+    } = options;
+
+    const args = [
+      '-p', // Print mode (non-interactive)
+      '--output-format', outputFormat,
+      '--tools', tools,
+      prompt
+    ];
+
+    const claude = spawn('claude', args, {
+      cwd,
+      env: process.env,
+      timeout
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    claude.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    claude.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    claude.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`Claude exited with code ${code}: ${stderr}`));
+        return;
+      }
+
+      try {
+        // Parse JSON output
+        if (outputFormat === 'json') {
+          const result = JSON.parse(stdout);
+          resolve(result);
+        } else {
+          resolve({ text: stdout });
+        }
+      } catch (err) {
+        // If JSON parse fails, return as text
+        resolve({ text: stdout, parseError: true });
+      }
+    });
+
+    claude.on('error', (err) => {
+      reject(new Error(`Failed to spawn claude: ${err.message}`));
+    });
+  });
+}
+
+/**
+ * Enhance content with AI
+ * @param {string} content - Original content
+ * @param {string} instruction - Enhancement instruction
+ * @param {string} filePath - Path to the file (for context)
+ * @returns {Promise<string>} - Enhanced content
+ */
+async function enhanceContent(content, instruction, filePath) {
+  const prompt = `
+You are enhancing marketing content. Here's the task:
+
+FILE: ${filePath}
+INSTRUCTION: ${instruction}
+
+ORIGINAL CONTENT:
+---
+${content}
+---
+
+Provide the improved content. Output ONLY the enhanced content, no explanations.
+`;
+
+  const result = await executeClaudeCode(prompt, {
+    tools: 'Read', // Read-only for safety
+    timeout: 60000
+  });
+
+  // Extract text from result
+  if (result.result) {
+    return result.result;
+  }
+  if (result.text) {
+    return result.text;
+  }
+  return content; // Fallback to original
+}
+
+/**
+ * Generate new content with AI
+ * @param {string} type - Content type (blog, social, email, etc.)
+ * @param {string} description - What to generate
+ * @param {object} context - Additional context (brand, etc.)
+ * @returns {Promise<string>} - Generated content
+ */
+async function generateContent(type, description, context = {}) {
+  const brandContext = context.brand
+    ? `BRAND CONTEXT: ${JSON.stringify(context.brand)}`
+    : '';
+
+  const prompt = `
+Generate marketing content.
+
+TYPE: ${type}
+DESCRIPTION: ${description}
+${brandContext}
+
+Generate high-quality ${type} content based on the description.
+Output ONLY the content, formatted appropriately for the type.
+`;
+
+  const result = await executeClaudeCode(prompt, {
+    tools: 'Read',
+    timeout: 90000
+  });
+
+  if (result.result) {
+    return result.result;
+  }
+  if (result.text) {
+    return result.text;
+  }
+  throw new Error('Failed to generate content');
+}
+
+/**
+ * Check if Claude Code CLI is available
+ * @returns {Promise<boolean>}
+ */
+async function isClaudeAvailable() {
+  return new Promise((resolve) => {
+    const claude = spawn('claude', ['--version'], { timeout: 5000 });
+    claude.on('close', (code) => resolve(code === 0));
+    claude.on('error', () => resolve(false));
+  });
+}
+
+module.exports = {
+  executeClaudeCode,
+  enhanceContent,
+  generateContent,
+  isClaudeAvailable
+};

package/.opencode/skills/content-hub/scripts/lib/brand-context.cjs

@@ -0,0 +1,118 @@
+/**
+ * Brand context extractor
+ * Extracts brand guidelines for Content Hub sidebar
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract hex colors from text
+ */
+function extractColors(text) {
+  const hexPattern = /#[0-9A-Fa-f]{6}\b/g;
+  return [...new Set(text.match(hexPattern) || [])];
+}
+
+/**
+ * Extract section from markdown
+ */
+function extractSection(content, heading) {
+  const regex = new RegExp(`###?\\s*${heading}[\\s\\S]*?(?=###?\\s|$)`, 'i');
+  const match = content.match(regex);
+  return match ? match[0] : '';
+}
+
+/**
+ * Extract brand context from markdown file
+ */
+function extractBrandContext(brandGuidelinesPath) {
+  const defaultContext = {
+    exists: false,
+    colors: { primary: [], secondary: [], neutral: [] },
+    typography: { heading: null, body: null },
+    voice: { personality: '', traits: [] },
+    summary: 'No brand guidelines found. Run /marketing:init to create them.'
+  };
+
+  if (!fs.existsSync(brandGuidelinesPath)) {
+    return defaultContext;
+  }
+
+  try {
+    const content = fs.readFileSync(brandGuidelinesPath, 'utf8');
+
+    // Extract colors
+    const primarySection = extractSection(content, 'Primary Colors');
+    const secondarySection = extractSection(content, 'Secondary Colors');
+    const neutralSection = extractSection(content, 'Neutral');
+
+    const colors = {
+      primary: extractColors(primarySection).slice(0, 5),
+      secondary: extractColors(secondarySection).slice(0, 5),
+      neutral: extractColors(neutralSection).slice(0, 5)
+    };
+
+    // Extract typography
+    const fontSection = extractSection(content, 'Font|Typography');
+    const headingMatch = fontSection.match(/heading[^']*['"]([^'"]+)['"]/i);
+    const bodyMatch = fontSection.match(/body[^']*['"]([^'"]+)['"]/i);
+
+    const typography = {
+      heading: headingMatch ? headingMatch[1] : null,
+      body: bodyMatch ? bodyMatch[1] : null
+    };
+
+    // Extract voice/personality
+    const personalitySection = extractSection(content, 'Brand Personality|Voice');
+    const traits = [];
+    const traitMatches = personalitySection.match(/\*\*([^*]+)\*\*/g);
+    if (traitMatches) {
+      traits.push(...traitMatches.map(t => t.replace(/\*\*/g, '').trim()).slice(0, 5));
+    }
+
+    // Build summary
+    const summaryParts = [];
+    if (colors.primary.length) summaryParts.push(`Primary: ${colors.primary[0]}`);
+    if (typography.heading) summaryParts.push(`Font: ${typography.heading}`);
+    if (traits.length) summaryParts.push(`Voice: ${traits.slice(0, 3).join(', ')}`);
+
+    return {
+      exists: true,
+      colors,
+      typography,
+      voice: {
+        personality: traits.join(', '),
+        traits
+      },
+      summary: summaryParts.join(' | ') || 'Brand guidelines loaded',
+      source: brandGuidelinesPath,
+      extractedAt: new Date().toISOString()
+    };
+
+  } catch (err) {
+    console.error('Error extracting brand context:', err);
+    return defaultContext;
+  }
+}
+
+/**
+ * Get brand context from project
+ */
+function getBrandContext(projectRoot) {
+  const possiblePaths = [
+    path.join(projectRoot, 'docs', 'brand-guidelines.md'),
+    path.join(projectRoot, 'docs', 'design-guidelines.md'),
+    path.join(projectRoot, 'brand-guidelines.md')
+  ];
+
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) {
+      return extractBrandContext(p);
+    }
+  }
+
+  return extractBrandContext(possiblePaths[0]); // Returns default context
+}
+
+module.exports = { getBrandContext, extractBrandContext };

package/.opencode/skills/content-hub/scripts/lib/port-finder.cjs

@@ -0,0 +1,43 @@
+/**
+ * Port finder utility - finds available port in range
+ * Used by content-hub server
+ */
+
+const net = require('net');
+
+const DEFAULT_PORT = 3457; // Different from markdown-novel-viewer (3456)
+const PORT_RANGE_END = 3500;
+
+/**
+ * Check if a port is available
+ */
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port);
+  });
+}
+
+/**
+ * Find first available port in range
+ */
+async function findAvailablePort(startPort = DEFAULT_PORT) {
+  for (let port = startPort; port <= PORT_RANGE_END; port++) {
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`No available port in range ${startPort}-${PORT_RANGE_END}`);
+}
+
+module.exports = {
+  isPortAvailable,
+  findAvailablePort,
+  DEFAULT_PORT,
+  PORT_RANGE_END
+};

package/.opencode/skills/content-hub/scripts/lib/process-mgr.cjs

@@ -0,0 +1,102 @@
+/**
+ * Process manager - handles PID files and server lifecycle
+ * Used by content-hub server
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PID_DIR = '/tmp';
+const PID_PREFIX = 'content-hub-';
+
+function getPidFilePath(port) {
+  return path.join(PID_DIR, `${PID_PREFIX}${port}.pid`);
+}
+
+function writePidFile(port, pid) {
+  fs.writeFileSync(getPidFilePath(port), String(pid));
+}
+
+function readPidFile(port) {
+  const pidPath = getPidFilePath(port);
+  if (fs.existsSync(pidPath)) {
+    return parseInt(fs.readFileSync(pidPath, 'utf8').trim(), 10);
+  }
+  return null;
+}
+
+function removePidFile(port) {
+  const pidPath = getPidFilePath(port);
+  if (fs.existsSync(pidPath)) fs.unlinkSync(pidPath);
+}
+
+function findRunningInstances() {
+  const instances = [];
+  const files = fs.readdirSync(PID_DIR);
+
+  for (const file of files) {
+    if (file.startsWith(PID_PREFIX) && file.endsWith('.pid')) {
+      const port = parseInt(file.replace(PID_PREFIX, '').replace('.pid', ''), 10);
+      const pid = readPidFile(port);
+      if (pid) {
+        try {
+          process.kill(pid, 0);
+          instances.push({ port, pid });
+        } catch {
+          removePidFile(port);
+        }
+      }
+    }
+  }
+  return instances;
+}
+
+function stopServer(port) {
+  const pid = readPidFile(port);
+  if (!pid) return false;
+  try {
+    process.kill(pid, 'SIGTERM');
+    removePidFile(port);
+    return true;
+  } catch {
+    removePidFile(port);
+    return false;
+  }
+}
+
+function stopAllServers() {
+  const instances = findRunningInstances();
+  let stopped = 0;
+  for (const { port, pid } of instances) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      removePidFile(port);
+      stopped++;
+    } catch {
+      removePidFile(port);
+    }
+  }
+  return stopped;
+}
+
+function setupShutdownHandlers(port, cleanup) {
+  const handler = () => {
+    if (cleanup) cleanup();
+    removePidFile(port);
+    process.exit(0);
+  };
+  process.on('SIGTERM', handler);
+  process.on('SIGINT', handler);
+}
+
+module.exports = {
+  getPidFilePath,
+  writePidFile,
+  readPidFile,
+  removePidFile,
+  findRunningInstances,
+  stopServer,
+  stopAllServers,
+  setupShutdownHandlers,
+  PID_PREFIX
+};

package/.opencode/skills/content-hub/scripts/lib/router.cjs

@@ -0,0 +1,276 @@
+/**
+ * Router - HTTP request routing for Content Hub
+ * Handles API endpoints and static file serving
+ */
+
+const fs = require('fs');
+const path = require('path');
+const url = require('url');
+
+// MIME types for static files
+const MIME_TYPES = {
+  '.html': 'text/html',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.pdf': 'application/pdf',
+  '.md': 'text/markdown',
+  '.txt': 'text/plain'
+};
+
+/**
+ * Check if path is safe (no directory traversal)
+ */
+function isPathSafe(reqPath, baseDir) {
+  const resolved = path.resolve(baseDir, reqPath);
+  return resolved.startsWith(path.resolve(baseDir));
+}
+
+const { enhanceContent, generateContent, isClaudeAvailable } = require('./ai-bridge.cjs');
+
+/**
+ * Parse JSON body from request
+ */
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', chunk => body += chunk);
+    req.on('end', () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (e) {
+        reject(new Error('Invalid JSON'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+/**
+ * Create router with config
+ */
+function createRouter(config) {
+  const {
+    assetsDir,
+    skillAssetsDir,
+    templatePath,
+    getManifest,
+    getBrandContext,
+    rescan,
+    projectRoot
+  } = config;
+
+  /**
+   * Route handler
+   */
+  return async function route(req, res) {
+    const parsedUrl = url.parse(req.url, true);
+    const pathname = parsedUrl.pathname;
+    const method = req.method;
+
+    // CORS headers for local development
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    try {
+      // API Routes
+      if (pathname === '/api/assets') {
+        const manifest = await getManifest();
+        sendJson(res, manifest);
+        return;
+      }
+
+      if (pathname === '/api/brand') {
+        const brand = await getBrandContext();
+        sendJson(res, brand);
+        return;
+      }
+
+      if (pathname === '/api/scan' && method === 'POST') {
+        const result = await rescan();
+        sendJson(res, { success: true, assets: result.totalAssets });
+        return;
+      }
+
+      // AI Bridge Routes
+      if (pathname === '/api/ai/status') {
+        const available = await isClaudeAvailable();
+        sendJson(res, { available, message: available ? 'Claude Code ready' : 'Claude Code not found' });
+        return;
+      }
+
+      if (pathname === '/api/ai/enhance' && method === 'POST') {
+        const body = await parseBody(req);
+        const { content, instruction, filePath } = body;
+
+        if (!content || !instruction) {
+          res.writeHead(400);
+          sendJson(res, { error: 'content and instruction required' });
+          return;
+        }
+
+        try {
+          const enhanced = await enhanceContent(content, instruction, filePath || 'unknown');
+          sendJson(res, { success: true, content: enhanced });
+        } catch (err) {
+          res.writeHead(500);
+          sendJson(res, { error: err.message });
+        }
+        return;
+      }
+
+      if (pathname === '/api/ai/generate' && method === 'POST') {
+        const body = await parseBody(req);
+        const { type, description } = body;
+
+        if (!type || !description) {
+          res.writeHead(400);
+          sendJson(res, { error: 'type and description required' });
+          return;
+        }
+
+        try {
+          const brand = await getBrandContext();
+          const generated = await generateContent(type, description, { brand });
+          sendJson(res, { success: true, content: generated });
+        } catch (err) {
+          res.writeHead(500);
+          sendJson(res, { error: err.message });
+        }
+        return;
+      }
+
+      // File Routes
+      if (pathname === '/api/file/read' && method === 'GET') {
+        const filePath = parsedUrl.query.path;
+        if (!filePath || !isPathSafe(filePath, assetsDir)) {
+          res.writeHead(400);
+          sendJson(res, { error: 'Invalid path' });
+          return;
+        }
+
+        const fullPath = path.join(assetsDir, filePath);
+        if (!fs.existsSync(fullPath)) {
+          res.writeHead(404);
+          sendJson(res, { error: 'File not found' });
+          return;
+        }
+
+        const content = fs.readFileSync(fullPath, 'utf8');
+        sendJson(res, { success: true, content, path: filePath });
+        return;
+      }
+
+      if (pathname === '/api/file/save' && method === 'POST') {
+        const body = await parseBody(req);
+        const { path: filePath, content } = body;
+
+        if (!filePath || content === undefined || !isPathSafe(filePath, assetsDir)) {
+          res.writeHead(400);
+          sendJson(res, { error: 'Invalid path or content' });
+          return;
+        }
+
+        const fullPath = path.join(assetsDir, filePath);
+        fs.writeFileSync(fullPath, content, 'utf8');
+        sendJson(res, { success: true, path: filePath });
+        return;
+      }
+
+      // Hub page
+      if (pathname === '/hub' || pathname === '/') {
+        const html = fs.readFileSync(templatePath, 'utf8');
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(html);
+        return;
+      }
+
+      // Skill static assets (/assets/*)
+      if (pathname.startsWith('/assets/')) {
+        const filePath = pathname.replace('/assets/', '');
+        serveStatic(res, skillAssetsDir, filePath);
+        return;
+      }
+
+      // User asset files (/file/*)
+      if (pathname.startsWith('/file/')) {
+        const filePath = pathname.replace('/file/', '');
+        serveStatic(res, assetsDir, filePath);
+        return;
+      }
+
+      // 404
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found' }));
+
+    } catch (err) {
+      console.error('Router error:', err);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Internal server error' }));
+    }
+  };
+}
+
+/**
+ * Send JSON response
+ */
+function sendJson(res, data) {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(data));
+}
+
+/**
+ * Serve static file
+ */
+function serveStatic(res, baseDir, filePath) {
+  // Security check
+  if (!isPathSafe(filePath, baseDir)) {
+    res.writeHead(403, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Forbidden' }));
+    return;
+  }
+
+  const fullPath = path.join(baseDir, filePath);
+
+  if (!fs.existsSync(fullPath)) {
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'File not found' }));
+    return;
+  }
+
+  const stat = fs.statSync(fullPath);
+  if (stat.isDirectory()) {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'Cannot serve directory' }));
+    return;
+  }
+
+  const ext = path.extname(fullPath).toLowerCase();
+  const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+
+  res.writeHead(200, {
+    'Content-Type': contentType,
+    'Content-Length': stat.size,
+    'Cache-Control': 'max-age=3600'
+  });
+
+  const stream = fs.createReadStream(fullPath);
+  stream.pipe(res);
+}
+
+module.exports = { createRouter, isPathSafe, MIME_TYPES };