claude-code-workflow 6.0.5 → 6.1.0

package/ccw/src/tools/classify-folders.js

@@ -0,0 +1,204 @@
+/**
+ * Classify Folders Tool
+ * Categorize folders by type for documentation generation
+ * Types: code (API.md + README.md), navigation (README.md only), skip (empty)
+ */
+
+import { readdirSync, statSync, existsSync } from 'fs';
+import { join, resolve, extname } from 'path';
+
+// Code file extensions
+const CODE_EXTENSIONS = [
+  '.ts', '.tsx', '.js', '.jsx',
+  '.py', '.go', '.java', '.rs',
+  '.c', '.cpp', '.cs', '.rb',
+  '.php', '.swift', '.kt'
+];
+
+/**
+ * Count code files in a directory (non-recursive)
+ */
+function countCodeFiles(dirPath) {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter(e => {
+      if (!e.isFile()) return false;
+      const ext = extname(e.name).toLowerCase();
+      return CODE_EXTENSIONS.includes(ext);
+    }).length;
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Count subdirectories in a directory
+ */
+function countSubdirs(dirPath) {
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter(e => e.isDirectory() && !e.name.startsWith('.')).length;
+  } catch (e) {
+    return 0;
+  }
+}
+
+/**
+ * Determine folder type
+ */
+function classifyFolder(dirPath) {
+  const codeFiles = countCodeFiles(dirPath);
+  const subdirs = countSubdirs(dirPath);
+
+  if (codeFiles > 0) {
+    return { type: 'code', codeFiles, subdirs }; // Generates API.md + README.md
+  } else if (subdirs > 0) {
+    return { type: 'navigation', codeFiles, subdirs }; // README.md only
+  } else {
+    return { type: 'skip', codeFiles, subdirs }; // Empty or no relevant content
+  }
+}
+
+/**
+ * Parse input from get_modules_by_depth format
+ * Format: depth:N|path:./path|files:N|types:[ext,ext]|has_claude:yes/no
+ */
+function parseModuleInput(line) {
+  const parts = {};
+  line.split('|').forEach(part => {
+    const [key, value] = part.split(':');
+    if (key && value !== undefined) {
+      parts[key] = value;
+    }
+  });
+  return parts;
+}
+
+/**
+ * Main execute function
+ */
+async function execute(params) {
+  const { input, path: targetPath } = params;
+
+  const results = [];
+
+  // Mode 1: Process piped input from get_modules_by_depth
+  if (input) {
+    let lines;
+
+    // Check if input is JSON (from ccw tool exec output)
+    if (typeof input === 'string' && input.trim().startsWith('{')) {
+      try {
+        const jsonInput = JSON.parse(input);
+        // Handle output from get_modules_by_depth tool (wrapped in result)
+        const output = jsonInput.result?.output || jsonInput.output;
+        if (output) {
+          lines = output.split('\n');
+        } else {
+          lines = [input];
+        }
+      } catch {
+        // Not JSON, treat as line-delimited text
+        lines = input.split('\n');
+      }
+    } else if (Array.isArray(input)) {
+      lines = input;
+    } else {
+      lines = input.split('\n');
+    }
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      const parsed = parseModuleInput(line);
+      const folderPath = parsed.path;
+
+      if (!folderPath) continue;
+
+      const basePath = targetPath ? resolve(process.cwd(), targetPath) : process.cwd();
+      const fullPath = resolve(basePath, folderPath);
+
+      if (!existsSync(fullPath) || !statSync(fullPath).isDirectory()) {
+        continue;
+      }
+
+      const classification = classifyFolder(fullPath);
+
+      results.push({
+        path: folderPath,
+        type: classification.type,
+        code_files: classification.codeFiles,
+        subdirs: classification.subdirs
+      });
+    }
+  }
+  // Mode 2: Classify a single directory
+  else if (targetPath) {
+    const fullPath = resolve(process.cwd(), targetPath);
+
+    if (!existsSync(fullPath)) {
+      throw new Error(`Directory not found: ${fullPath}`);
+    }
+
+    if (!statSync(fullPath).isDirectory()) {
+      throw new Error(`Not a directory: ${fullPath}`);
+    }
+
+    const classification = classifyFolder(fullPath);
+
+    results.push({
+      path: targetPath,
+      type: classification.type,
+      code_files: classification.codeFiles,
+      subdirs: classification.subdirs
+    });
+  }
+  else {
+    throw new Error('Either "input" or "path" parameter is required');
+  }
+
+  // Format output
+  const output = results.map(r =>
+    `${r.path}|${r.type}|code:${r.code_files}|dirs:${r.subdirs}`
+  ).join('\n');
+
+  return {
+    total: results.length,
+    by_type: {
+      code: results.filter(r => r.type === 'code').length,
+      navigation: results.filter(r => r.type === 'navigation').length,
+      skip: results.filter(r => r.type === 'skip').length
+    },
+    results,
+    output
+  };
+}
+
+/**
+ * Tool Definition
+ */
+export const classifyFoldersTool = {
+  name: 'classify_folders',
+  description: `Classify folders by type for documentation generation.
+Types:
+- code: Contains code files (generates API.md + README.md)
+- navigation: Contains subdirectories only (generates README.md only)
+- skip: Empty or no relevant content
+
+Input: Either piped output from get_modules_by_depth or a single directory path.`,
+  parameters: {
+    type: 'object',
+    properties: {
+      input: {
+        type: 'string',
+        description: 'Piped input from get_modules_by_depth (one module per line)'
+      },
+      path: {
+        type: 'string',
+        description: 'Single directory path to classify'
+      }
+    },
+    required: []
+  },
+  execute
+};

package/ccw/src/tools/convert-tokens-to-css.js

@@ -0,0 +1,250 @@
+/**
+ * Convert Tokens to CSS Tool
+ * Transform design-tokens.json to CSS custom properties
+ */
+
+/**
+ * Generate Google Fonts import URL
+ */
+function generateFontImport(fonts) {
+  if (!fonts || typeof fonts !== 'object') return '';
+
+  const fontParams = [];
+  const processedFonts = new Set();
+
+  // Extract font families from typography.font_family
+  Object.values(fonts).forEach(fontValue => {
+    if (typeof fontValue !== 'string') return;
+
+    // Get the primary font (before comma)
+    const primaryFont = fontValue.split(',')[0].trim().replace(/['"]/g, '');
+
+    // Skip system fonts
+    const systemFonts = ['system-ui', 'sans-serif', 'serif', 'monospace', 'cursive', 'fantasy'];
+    if (systemFonts.includes(primaryFont.toLowerCase())) return;
+    if (processedFonts.has(primaryFont)) return;
+
+    processedFonts.add(primaryFont);
+
+    // URL encode font name
+    const encodedFont = primaryFont.replace(/ /g, '+');
+
+    // Special handling for common fonts
+    const specialFonts = {
+      'Comic Neue': 'Comic+Neue:wght@300;400;700',
+      'Patrick Hand': 'Patrick+Hand:wght@400;700',
+      'Caveat': 'Caveat:wght@400;700',
+      'Dancing Script': 'Dancing+Script:wght@400;700'
+    };
+
+    if (specialFonts[primaryFont]) {
+      fontParams.push(`family=${specialFonts[primaryFont]}`);
+    } else {
+      fontParams.push(`family=${encodedFont}:wght@400;500;600;700`);
+    }
+  });
+
+  if (fontParams.length === 0) return '';
+
+  return `@import url('https://fonts.googleapis.com/css2?${fontParams.join('&')}&display=swap');`;
+}
+
+/**
+ * Generate CSS variables for a category
+ */
+function generateCssVars(prefix, obj, indent = '  ') {
+  if (!obj || typeof obj !== 'object') return [];
+
+  const lines = [];
+  Object.entries(obj).forEach(([key, value]) => {
+    const varName = `--${prefix}-${key.replace(/_/g, '-')}`;
+    lines.push(`${indent}${varName}: ${value};`);
+  });
+  return lines;
+}
+
+/**
+ * Main execute function
+ */
+async function execute(params) {
+  const { input } = params;
+
+  if (!input) {
+    throw new Error('Parameter "input" (design tokens JSON) is required');
+  }
+
+  // Parse input
+  let tokens;
+  try {
+    tokens = typeof input === 'string' ? JSON.parse(input) : input;
+  } catch (e) {
+    throw new Error(`Invalid JSON input: ${e.message}`);
+  }
+
+  const lines = [];
+
+  // Header
+  const styleName = tokens.meta?.name || 'Design Tokens';
+  lines.push('/* ========================================');
+  lines.push(`   Design Tokens: ${styleName}`);
+  lines.push('   Auto-generated from design-tokens.json');
+  lines.push('   ======================================== */');
+  lines.push('');
+
+  // Google Fonts import
+  if (tokens.typography?.font_family) {
+    const fontImport = generateFontImport(tokens.typography.font_family);
+    if (fontImport) {
+      lines.push('/* Import Web Fonts */');
+      lines.push(fontImport);
+      lines.push('');
+    }
+  }
+
+  // CSS Custom Properties
+  lines.push(':root {');
+
+  // Colors
+  if (tokens.colors) {
+    if (tokens.colors.brand) {
+      lines.push('  /* Colors - Brand */');
+      lines.push(...generateCssVars('color-brand', tokens.colors.brand));
+      lines.push('');
+    }
+    if (tokens.colors.surface) {
+      lines.push('  /* Colors - Surface */');
+      lines.push(...generateCssVars('color-surface', tokens.colors.surface));
+      lines.push('');
+    }
+    if (tokens.colors.semantic) {
+      lines.push('  /* Colors - Semantic */');
+      lines.push(...generateCssVars('color-semantic', tokens.colors.semantic));
+      lines.push('');
+    }
+    if (tokens.colors.text) {
+      lines.push('  /* Colors - Text */');
+      lines.push(...generateCssVars('color-text', tokens.colors.text));
+      lines.push('');
+    }
+    if (tokens.colors.border) {
+      lines.push('  /* Colors - Border */');
+      lines.push(...generateCssVars('color-border', tokens.colors.border));
+      lines.push('');
+    }
+  }
+
+  // Typography
+  if (tokens.typography) {
+    if (tokens.typography.font_family) {
+      lines.push('  /* Typography - Font Family */');
+      lines.push(...generateCssVars('font-family', tokens.typography.font_family));
+      lines.push('');
+    }
+    if (tokens.typography.font_size) {
+      lines.push('  /* Typography - Font Size */');
+      lines.push(...generateCssVars('font-size', tokens.typography.font_size));
+      lines.push('');
+    }
+    if (tokens.typography.font_weight) {
+      lines.push('  /* Typography - Font Weight */');
+      lines.push(...generateCssVars('font-weight', tokens.typography.font_weight));
+      lines.push('');
+    }
+    if (tokens.typography.line_height) {
+      lines.push('  /* Typography - Line Height */');
+      lines.push(...generateCssVars('line-height', tokens.typography.line_height));
+      lines.push('');
+    }
+    if (tokens.typography.letter_spacing) {
+      lines.push('  /* Typography - Letter Spacing */');
+      lines.push(...generateCssVars('letter-spacing', tokens.typography.letter_spacing));
+      lines.push('');
+    }
+  }
+
+  // Spacing
+  if (tokens.spacing) {
+    lines.push('  /* Spacing */');
+    lines.push(...generateCssVars('spacing', tokens.spacing));
+    lines.push('');
+  }
+
+  // Border Radius
+  if (tokens.border_radius) {
+    lines.push('  /* Border Radius */');
+    lines.push(...generateCssVars('border-radius', tokens.border_radius));
+    lines.push('');
+  }
+
+  // Shadows
+  if (tokens.shadows) {
+    lines.push('  /* Shadows */');
+    lines.push(...generateCssVars('shadow', tokens.shadows));
+    lines.push('');
+  }
+
+  // Breakpoints
+  if (tokens.breakpoints) {
+    lines.push('  /* Breakpoints */');
+    lines.push(...generateCssVars('breakpoint', tokens.breakpoints));
+    lines.push('');
+  }
+
+  lines.push('}');
+  lines.push('');
+
+  // Global Font Application
+  lines.push('/* ========================================');
+  lines.push('   Global Font Application');
+  lines.push('   ======================================== */');
+  lines.push('');
+  lines.push('body {');
+  lines.push('  font-family: var(--font-family-body);');
+  lines.push('  font-size: var(--font-size-base);');
+  lines.push('  line-height: var(--line-height-normal);');
+  lines.push('  color: var(--color-text-primary);');
+  lines.push('  background-color: var(--color-surface-background);');
+  lines.push('}');
+  lines.push('');
+  lines.push('h1, h2, h3, h4, h5, h6, legend {');
+  lines.push('  font-family: var(--font-family-heading);');
+  lines.push('}');
+  lines.push('');
+  lines.push('/* Reset default margins for better control */');
+  lines.push('* {');
+  lines.push('  margin: 0;');
+  lines.push('  padding: 0;');
+  lines.push('  box-sizing: border-box;');
+  lines.push('}');
+
+  const css = lines.join('\n');
+
+  return {
+    style_name: styleName,
+    lines_count: lines.length,
+    css
+  };
+}
+
+/**
+ * Tool Definition
+ */
+export const convertTokensToCssTool = {
+  name: 'convert_tokens_to_css',
+  description: `Transform design-tokens.json to CSS custom properties.
+Generates:
+- Google Fonts @import URL
+- CSS custom properties for colors, typography, spacing, etc.
+- Global font application rules`,
+  parameters: {
+    type: 'object',
+    properties: {
+      input: {
+        type: 'string',
+        description: 'Design tokens JSON string or object'
+      }
+    },
+    required: ['input']
+  },
+  execute
+};