@polymorphism-tech/morph-spec 1.0.4 → 2.1.0

package/bin/render-template.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+/**
+ * MORPH-SPEC Template Renderer
+ *
+ * Renders templates by replacing {{PLACEHOLDER}} with actual values.
+ *
+ * Usage:
+ *   node bin/render-template.js <template-path> <output-path> <variables-json>
+ *
+ * Example:
+ *   node bin/render-template.js \
+ *     content/.morph/templates/spec.md \
+ *     .morph/project/outputs/my-feature/spec.md \
+ *     '{"FEATURE_NAME":"my-feature","STACK":"Blazor","DATE":"2024-01-15"}'
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ANSI color codes
+const colors = {
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  reset: '\x1b[0m'
+};
+
+/**
+ * Load config to get default values
+ */
+function loadConfig() {
+  const configPaths = [
+    path.join(process.cwd(), '.morph/config/config.json'),
+    path.join(process.cwd(), 'content/.morph/config/config.json'),
+    path.join(__dirname, '../content/.morph/config/config.template.json')
+  ];
+
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+      } catch (error) {
+        // Continue to next path
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get default variables from config and environment
+ */
+function getDefaultVariables() {
+  const config = loadConfig();
+  const now = new Date();
+
+  return {
+    DATE: now.toISOString().split('T')[0],
+    YEAR: now.getFullYear().toString(),
+    AUTHOR: config?.project?.author || 'MORPH-SPEC',
+    PROJECT_NAME: config?.project?.name || 'Project',
+    STACK: config?.project?.stack || 'Blazor',
+    NAMESPACE: config?.project?.namespace || 'Project'
+  };
+}
+
+/**
+ * Convert string to various case formats
+ */
+function transformCase(str) {
+  return {
+    // kebab-case → PascalCase
+    pascal: str
+      .split('-')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join(''),
+
+    // kebab-case → camelCase
+    camel: str
+      .split('-')
+      .map((word, index) =>
+        index === 0
+          ? word.toLowerCase()
+          : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
+      )
+      .join(''),
+
+    // kebab-case → Title Case
+    title: str
+      .split('-')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join(' '),
+
+    // kebab-case → UPPER_SNAKE_CASE
+    upperSnake: str.toUpperCase().replace(/-/g, '_'),
+
+    // kebab-case → lower_snake_case
+    lowerSnake: str.toLowerCase().replace(/-/g, '_')
+  };
+}
+
+/**
+ * Render template by replacing placeholders
+ */
+function renderTemplate(templatePath, variables) {
+  if (!fs.existsSync(templatePath)) {
+    throw new Error(`Template file not found: ${templatePath}`);
+  }
+
+  let content = fs.readFileSync(templatePath, 'utf-8');
+
+  // Get default variables
+  const defaults = getDefaultVariables();
+
+  // Merge with provided variables (provided takes precedence)
+  const allVariables = { ...defaults, ...variables };
+
+  // Auto-generate case transformations for FEATURE_NAME if provided
+  if (allVariables.FEATURE_NAME) {
+    const featureName = allVariables.FEATURE_NAME;
+    const transformations = transformCase(featureName);
+
+    allVariables.FEATURE_NAME_PASCAL = transformations.pascal;
+    allVariables.FEATURE_NAME_CAMEL = transformations.camel;
+    allVariables.FEATURE_NAME_TITLE = transformations.title;
+    allVariables.FEATURE_NAME_UPPER_SNAKE = transformations.upperSnake;
+    allVariables.FEATURE_NAME_LOWER_SNAKE = transformations.lowerSnake;
+
+    // Backward compatibility: FEATURE_TITLE maps to FEATURE_NAME_TITLE
+    if (!allVariables.FEATURE_TITLE) {
+      allVariables.FEATURE_TITLE = transformations.title;
+    }
+  }
+
+  // Track which placeholders were replaced
+  const replacedPlaceholders = new Set();
+  const unreplacedPlaceholders = new Set();
+
+  // Replace all placeholders
+  for (const [key, value] of Object.entries(allVariables)) {
+    const placeholder = `{{${key}}}`;
+    if (content.includes(placeholder)) {
+      content = content.replaceAll(placeholder, value);
+      replacedPlaceholders.add(key);
+    }
+  }
+
+  // Find unreplaced placeholders
+  const placeholderRegex = /\{\{([A-Z_]+)\}\}/g;
+  let match;
+  while ((match = placeholderRegex.exec(content)) !== null) {
+    unreplacedPlaceholders.add(match[1]);
+  }
+
+  return {
+    content,
+    replacedPlaceholders: Array.from(replacedPlaceholders),
+    unreplacedPlaceholders: Array.from(unreplacedPlaceholders)
+  };
+}
+
+/**
+ * Print help message
+ */
+function printHelp() {
+  console.log(`
+${colors.cyan}MORPH-SPEC Template Renderer${colors.reset}
+
+${colors.green}Usage:${colors.reset}
+  node bin/render-template.js <template-path> <output-path> <variables-json>
+
+${colors.green}Arguments:${colors.reset}
+  template-path    Path to the template file (required)
+  output-path      Path where rendered output will be written (required)
+  variables-json   JSON object with variables to replace (required)
+
+${colors.green}Standard Placeholders:${colors.reset}
+  {{FEATURE_NAME}}           - kebab-case feature name (e.g., "scheduled-reports")
+  {{FEATURE_NAME_PASCAL}}    - PascalCase (e.g., "ScheduledReports")
+  {{FEATURE_NAME_CAMEL}}     - camelCase (e.g., "scheduledReports")
+  {{FEATURE_NAME_TITLE}}     - Title Case (e.g., "Scheduled Reports")
+  {{FEATURE_NAME_UPPER_SNAKE}} - UPPER_SNAKE_CASE (e.g., "SCHEDULED_REPORTS")
+  {{FEATURE_NAME_LOWER_SNAKE}} - lower_snake_case (e.g., "scheduled_reports")
+  {{FEATURE_TITLE}}          - Alias for FEATURE_NAME_TITLE
+  {{STACK}}                  - Project stack (e.g., "Blazor", "Next.js")
+  {{DATE}}                   - Current date (YYYY-MM-DD)
+  {{YEAR}}                   - Current year
+  {{AUTHOR}}                 - Author name (from config.json)
+  {{PROJECT_NAME}}           - Project name (from config.json)
+  {{NAMESPACE}}              - C# namespace (from config.json)
+
+${colors.green}Example:${colors.reset}
+  node bin/render-template.js \\
+    content/.morph/templates/spec.md \\
+    .morph/project/outputs/scheduled-reports/spec.md \\
+    '{"FEATURE_NAME":"scheduled-reports","STACK":"Blazor"}'
+
+${colors.green}Flags:${colors.reset}
+  --help, -h       Show this help message
+  --verbose, -v    Show detailed replacement information
+  --dry-run, -d    Preview output without writing file
+
+${colors.yellow}Note:${colors.reset} DATE, YEAR, AUTHOR, PROJECT_NAME, STACK, NAMESPACE are auto-populated from config.json
+  `);
+}
+
+/**
+ * Main CLI logic
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  // Check for help flag
+  if (args.includes('--help') || args.includes('-h')) {
+    printHelp();
+    process.exit(0);
+  }
+
+  // Parse flags
+  const verbose = args.includes('--verbose') || args.includes('-v');
+  const dryRun = args.includes('--dry-run') || args.includes('-d');
+
+  // Filter out flags
+  const flags = ['--verbose', '-v', '--dry-run', '-d', '--help', '-h'];
+  const cleanArgs = args.filter(arg => !flags.includes(arg));
+
+  // Validate arguments
+  if (cleanArgs.length < 3) {
+    console.error(`${colors.red}❌ Error: Missing required arguments${colors.reset}\n`);
+    printHelp();
+    process.exit(1);
+  }
+
+  const [templatePath, outputPath, variablesJson] = cleanArgs;
+
+  // Parse variables JSON
+  let variables;
+  try {
+    variables = JSON.parse(variablesJson);
+  } catch (error) {
+    console.error(`${colors.red}❌ Error: Invalid JSON in variables argument${colors.reset}`);
+    console.error(`   ${error.message}\n`);
+    process.exit(1);
+  }
+
+  try {
+    // Render template
+    const { content, replacedPlaceholders, unreplacedPlaceholders } = renderTemplate(
+      templatePath,
+      variables
+    );
+
+    // Dry run: just preview
+    if (dryRun) {
+      console.log(`${colors.cyan}📋 DRY RUN - Preview (file will NOT be written)${colors.reset}\n`);
+      console.log(content);
+      console.log(`\n${colors.cyan}═══════════════════════════════════════════${colors.reset}`);
+    } else {
+      // Create output directory if it doesn't exist
+      const outputDir = path.dirname(outputPath);
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+
+      // Write rendered content
+      fs.writeFileSync(outputPath, content, 'utf-8');
+      console.log(`${colors.green}✅ Template rendered successfully${colors.reset}`);
+      console.log(`   Output: ${outputPath}`);
+    }
+
+    // Verbose output
+    if (verbose || unreplacedPlaceholders.length > 0) {
+      console.log(`\n${colors.cyan}📊 Replacement Summary:${colors.reset}`);
+      console.log(`   ${colors.green}Replaced:${colors.reset} ${replacedPlaceholders.length} placeholders`);
+
+      if (replacedPlaceholders.length > 0) {
+        console.log(`   ${replacedPlaceholders.map(p => `{{${p}}}`).join(', ')}`);
+      }
+
+      if (unreplacedPlaceholders.length > 0) {
+        console.log(`\n   ${colors.yellow}⚠️  Unreplaced:${colors.reset} ${unreplacedPlaceholders.length} placeholders`);
+        console.log(`   ${unreplacedPlaceholders.map(p => `{{${p}}}`).join(', ')}`);
+      }
+    }
+
+    process.exit(0);
+  } catch (error) {
+    console.error(`${colors.red}❌ Error: ${error.message}${colors.reset}`);
+    process.exit(1);
+  }
+}
+
+// Run CLI
+main();

package/bin/semantic-detect-agents.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * MORPH-SPEC Semantic Agent Detection (LLM-based)
+ *
+ * Uses LLM analysis to detect which agents should be activated based on user request.
+ * More accurate than keyword matching - understands context and implicit needs.
+ *
+ * Usage:
+ *   export ANTHROPIC_API_KEY=sk-...
+ *   node bin/semantic-detect-agents.js "user request here"
+ *
+ * Falls back to keyword-based detection if API key not available.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// ANSI colors
+const colors = {
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+  reset: '\x1b[0m'
+};
+
+/**
+ * Call Anthropic Claude API for semantic analysis
+ */
+async function callClaudeAPI(userRequest, agentDescriptions) {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+
+  if (!apiKey) {
+    return null; // Will fall back to keyword detection
+  }
+
+  const prompt = `You are an expert at analyzing software development requests and determining which specialist agents are needed.
+
+Given this user request:
+"${userRequest}"
+
+And these available specialist agents:
+${agentDescriptions}
+
+Analyze the request and determine which specialist agents should be activated. Consider:
+- Explicit mentions (e.g., "create a dashboard" → UI/UX Designer)
+- Implicit needs (e.g., "show data to users" → UI/UX Designer)
+- Technical requirements (e.g., "scheduled tasks" → Hangfire Orchestrator)
+- Architecture patterns (e.g., "RAG pipeline" → AI System Architect)
+
+Respond with ONLY a JSON array of agent IDs, like:
+["uiux-designer", "hangfire-orchestrator"]
+
+If no specialists are needed, respond with: []
+Do not include core agents (they are always active).`;
+
+  try {
+    const response = await fetch('https://api.anthropic.com/v1/messages', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01'
+      },
+      body: JSON.stringify({
+        model: 'claude-3-haiku-20240307',
+        max_tokens: 200,
+        messages: [{
+          role: 'user',
+          content: prompt
+        }]
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      console.error(`${colors.yellow}⚠ Claude API error: ${error}${colors.reset}`);
+      return null;
+    }
+
+    const data = await response.json();
+    const content = data.content[0].text.trim();
+
+    // Parse JSON response
+    const agentIds = JSON.parse(content);
+    return agentIds;
+  } catch (error) {
+    console.error(`${colors.yellow}⚠ Claude API failed: ${error.message}${colors.reset}`);
+    return null;
+  }
+}
+
+/**
+ * Fallback: keyword-based detection (existing behavior)
+ */
+function keywordBasedDetection(userRequest) {
+  console.log(`${colors.yellow}ℹ Using keyword-based detection (fallback)${colors.reset}`);
+
+  try {
+    const result = execSync(`node bin/detect-agents.js "${userRequest}" --json`, {
+      encoding: 'utf-8',
+      cwd: process.cwd()
+    });
+
+    const parsed = JSON.parse(result);
+    return parsed.specialists || [];
+  } catch (error) {
+    console.error(`${colors.red}✗ Fallback detection failed: ${error.message}${colors.reset}`);
+    return [];
+  }
+}
+
+/**
+ * Load agent descriptions for LLM context
+ */
+function loadAgentDescriptions() {
+  const agentsPath = path.join(process.cwd(), 'content/.morph/config/agents.json');
+
+  if (!fs.existsSync(agentsPath)) {
+    throw new Error('agents.json not found');
+  }
+
+  const agents = JSON.parse(fs.readFileSync(agentsPath, 'utf-8'));
+  const specialists = agents.agents.specialists || [];
+
+  return specialists.map(agent =>
+    `- ${agent.id}: ${agent.description}`
+  ).join('\n');
+}
+
+/**
+ * Print detection results
+ */
+function printResults(agentIds, method, userRequest) {
+  console.log(`\n${colors.cyan}╔════════════════════════════════════════════════╗${colors.reset}`);
+  console.log(`${colors.cyan}║     MORPH-SPEC SEMANTIC AGENT DETECTION        ║${colors.reset}`);
+  console.log(`${colors.cyan}╚════════════════════════════════════════════════╝${colors.reset}\n`);
+
+  console.log(`${colors.gray}Request:${colors.reset} "${userRequest}"`);
+  console.log(`${colors.gray}Method:${colors.reset} ${method}`);
+  console.log(`${colors.gray}Agents Detected:${colors.reset} ${agentIds.length}`);
+
+  if (agentIds.length > 0) {
+    console.log('');
+    agentIds.forEach(id => {
+      console.log(`  ${colors.green}✓${colors.reset} ${id}`);
+    });
+  } else {
+    console.log(`\n  ${colors.gray}(No specialist agents needed)${colors.reset}`);
+  }
+
+  console.log('');
+}
+
+/**
+ * Print help
+ */
+function printHelp() {
+  console.log(`
+${colors.cyan}MORPH-SPEC Semantic Agent Detection${colors.reset}
+
+Uses LLM analysis to detect which agents should be activated.
+More accurate than keyword matching - understands context.
+
+${colors.green}Setup:${colors.reset}
+  export ANTHROPIC_API_KEY=sk-ant-...
+
+${colors.green}Usage:${colors.reset}
+  node bin/semantic-detect-agents.js "user request here"
+
+${colors.green}Examples:${colors.reset}
+  # Detects UI/UX Designer (implicit need)
+  node bin/semantic-detect-agents.js "sistema que mostra dados ao usuário"
+
+  # Detects Hangfire Orchestrator
+  node bin/semantic-detect-agents.js "processar arquivos todo dia às 3h"
+
+  # Detects AI System Architect
+  node bin/semantic-detect-agents.js "pipeline de RAG com chunking"
+
+${colors.green}Fallback:${colors.reset}
+  If ANTHROPIC_API_KEY is not set, falls back to keyword-based detection.
+
+${colors.green}Benefits:${colors.reset}
+  ✓ Understands context ("show data to users" → UI)
+  ✓ Works in any language (not just keywords)
+  ✓ Eliminates false positives/negatives
+  ✓ Detects implicit needs
+
+${colors.green}Output:${colors.reset}
+  Prints detected agent IDs, one per line, for use in scripts.
+  `);
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+    printHelp();
+    process.exit(args.length === 0 ? 1 : 0);
+  }
+
+  const userRequest = args.join(' ');
+  const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+
+  let agentIds;
+  let method;
+
+  if (hasApiKey) {
+    method = `${colors.green}LLM-based (Claude Haiku)${colors.reset}`;
+    const agentDescriptions = loadAgentDescriptions();
+    agentIds = await callClaudeAPI(userRequest, agentDescriptions);
+
+    if (!agentIds) {
+      // API failed, fall back
+      method = `${colors.yellow}Keyword-based (API fallback)${colors.reset}`;
+      agentIds = keywordBasedDetection(userRequest);
+    }
+  } else {
+    method = `${colors.yellow}Keyword-based (no API key)${colors.reset}`;
+    agentIds = keywordBasedDetection(userRequest);
+  }
+
+  printResults(agentIds, method, userRequest);
+
+  // Output for scripting (one ID per line)
+  if (args.includes('--quiet') || args.includes('-q')) {
+    console.clear();
+    agentIds.forEach(id => console.log(id));
+  }
+}
+
+main().catch(error => {
+  console.error(`${colors.red}✗ Error: ${error.message}${colors.reset}`);
+  process.exit(1);
+});