@polymorphism-tech/morph-spec 1.0.4 → 2.0.0

package/package.json

@@ -1,28 +1,37 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "1.0.4",
-  "description": "MORPH-SPEC: Methodical Orchestration for Reliable Production-ready SPEC-driven development framework for Claude Code",
+  "version": "2.0.0",
+  "description": "MORPH-SPEC v2.0: AI-First development framework with .NET 10, Microsoft Agent Framework, and Fluent UI Blazor",
   "keywords": [
     "claude-code",
     "claude",
     "ai-coding",
+    "ai-first",
     "spec-driven",
     "dotnet",
+    "dotnet10",
     "blazor",
+    "agent-framework",
+    "fluent-ui",
     "framework",
     "developer-tools",
     "morph",
-    "polymorphism"
+    "polymorphism",
+    "micro-saas"
   ],
   "main": "src/index.js",
   "bin": {
-    "morph-spec": "./bin/morph-spec.js"
+    "morph-spec": "bin/morph-spec.js"
   },
   "files": [
     "bin/",
     "src/",
+    "detectors/",
     "content/",
-    "README.md"
+    "docs/",
+    "README.md",
+    "LICENSE",
+    "CLAUDE.md"
   ],
   "type": "module",
   "engines": {
@@ -30,22 +39,40 @@
   },
   "scripts": {
     "start": "node bin/morph-spec.js",
-    "test": "node --test"
+    "test": "node --test",
+    "test:coverage": "c8 --reporter=text --reporter=html --reporter=lcov node --test",
+    "test:coverage:summary": "c8 --reporter=text-summary node --test",
+    "docs": "jsdoc -c jsdoc.json",
+    "docs:watch": "jsdoc -c jsdoc.json --watch",
+    "docs:serve": "npx http-server docs/api -p 8080 -o"
   },
   "dependencies": {
+    "ajv": "^8.12.0",
+    "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "fs-extra": "^11.2.0",
-    "ora": "^8.0.0"
+    "glob": "^10.3.0",
+    "ora": "^8.0.0",
+    "yaml": "^2.3.4"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/polymorphism-tech/morph-spec-framework.git"
+    "url": "git+https://github.com/lucasPolymorphism/morph-spec-framework.git"
   },
-  "author": "Polymorphism Tech",
-  "license": "MIT",
-  "homepage": "https://github.com/polymorphism-tech/morph-spec-framework#readme",
+  "author": "Polymorphism Tech <contact@polymorphism.com.br>",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://polymorphism.com.br/morph-spec",
   "bugs": {
-    "url": "https://github.com/polymorphism-tech/morph-spec-framework/issues"
+    "email": "support@polymorphism.com.br"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "c8": "^10.1.3",
+    "docdash": "^2.0.2",
+    "jsdoc": "^4.0.5"
   }
 }

package/src/commands/cost.js

@@ -0,0 +1,181 @@
+/**
+ * MORPH-SPEC Cost Command
+ * CLI wrapper for cost calculation operations
+ */
+
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import * as CostCalculator from '../lib/cost-calculator.js';
+
+// ============================================================================
+// Command Function
+// ============================================================================
+
+/**
+ * Calculate Azure infrastructure costs from Bicep files
+ * @param {string} bicepFiles - File path or glob pattern
+ * @param {Object} options - CLI options
+ */
+export async function costCommand(bicepFiles, options) {
+  if (!bicepFiles) {
+    logger.error('Bicep file path required');
+    logger.dim('  Usage: morph-spec cost <bicep-files>');
+    logger.blank();
+    logger.dim('  Examples:');
+    logger.dim('    morph-spec cost infra/main.bicep');
+    logger.dim('    morph-spec cost "infra/**/*.bicep"');
+    process.exit(1);
+  }
+
+  logger.header('MORPH-SPEC Cost Calculator');
+  logger.blank();
+
+  const spinner = ora('Parsing Bicep files...').start();
+
+  try {
+    // Calculate costs
+    const result = CostCalculator.calculateBicepCost(bicepFiles, {
+      configPath: options.config
+    });
+
+    spinner.succeed(`Found ${result.breakdown.length} resources`);
+    logger.blank();
+
+    // JSON output
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    // Verbose output (table format)
+    if (options.verbose) {
+      displayVerbose(result);
+    } else {
+      displaySummary(result);
+    }
+
+    // Exit code based on cost thresholds
+    if (result.requiresADR && options.strict) {
+      logger.blank();
+      logger.error('Cost exceeds ADR threshold!');
+      logger.dim('  Add ADR in decisions.md or use --no-strict');
+      process.exit(1);
+    }
+
+  } catch (error) {
+    spinner.fail('Cost calculation failed');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}
+
+// ============================================================================
+// Display Functions
+// ============================================================================
+
+/**
+ * Display summary (default output)
+ */
+function displaySummary(result) {
+  logger.header('Cost Summary');
+  logger.blank();
+
+  // Total cost
+  const costColor = result.requiresADR ? 'red' : result.requiresApproval ? 'yellow' : 'green';
+  logger.info(`Monthly Cost: ${chalk[costColor](`$${result.monthly.toFixed(2)}`)}`);
+  logger.dim(`  Currency: ${result.currency}`);
+  logger.dim(`  Region: ${result.region}`);
+  logger.blank();
+
+  // Status
+  if (result.isFreeTier) {
+    logger.success('✓ All resources use free tier');
+  } else {
+    if (result.requiresADR) {
+      logger.warn('⚠️  Requires ADR in decisions.md (cost > $' + result.limits.requiresADR + ')');
+    } else if (result.requiresApproval) {
+      logger.warn('⚠️  Requires approval (cost > $' + result.limits.freeTierOnly + ')');
+    } else {
+      logger.success('✓ Within free tier limits');
+    }
+  }
+  logger.blank();
+
+  // Top 3 expensive resources
+  if (result.breakdown.length > 0) {
+    logger.header('Top Resources:');
+    const sorted = [...result.breakdown].sort((a, b) => b.cost - a.cost);
+    sorted.slice(0, 3).forEach(item => {
+      const costStr = chalk.cyan(`$${item.cost.toFixed(2)}/mo`);
+      logger.dim(`  - ${item.name} (${item.sku}): ${costStr}`);
+    });
+    logger.blank();
+  }
+
+  // Warnings
+  if (result.warnings.length > 0) {
+    logger.header('Warnings:');
+    result.warnings.forEach(warning => {
+      logger.warn(`  ${warning}`);
+    });
+    logger.blank();
+  }
+
+  // Next steps
+  if (result.requiresADR) {
+    logger.header('Next Steps:');
+    logger.dim('  1. Document cost justification in decisions.md');
+    logger.dim('  2. Include ADR with cost breakdown');
+    logger.dim('  3. Get approval before deploying');
+    logger.blank();
+  }
+}
+
+/**
+ * Display verbose (table format)
+ */
+function displayVerbose(result) {
+  logger.blank();
+  console.log('╔════════════════════════════════════════════════════════════════╗');
+  console.log('║                 MORPH-SPEC COST CALCULATOR                     ║');
+  console.log('╠════════════════════════════════════════════════════════════════╣');
+  console.log(`║ Region: ${result.region.padEnd(54)}║`);
+  console.log(`║ Currency: ${result.currency.padEnd(52)}║`);
+  console.log('╠════════════════════════════════════════════════════════════════╣');
+  console.log('║ RESOURCES                                                      ║');
+  console.log('╠════════════════════════════════════════════════════════════════╣');
+
+  for (const item of result.breakdown) {
+    const costStr = `$${item.cost.toFixed(2)}/mo`;
+    const nameStr = `${item.name} (${item.sku})`;
+    console.log(`║ ${nameStr.substring(0, 40).padEnd(40)} ${costStr.padStart(20)}║`);
+  }
+
+  console.log('╠════════════════════════════════════════════════════════════════╣');
+  console.log('║ SUMMARY                                                        ║');
+  console.log('╠════════════════════════════════════════════════════════════════╣');
+  console.log(`║ Total Monthly Cost: $${result.monthly.toFixed(2).padStart(42)}║`);
+  console.log(`║ Requires Approval: ${(result.requiresApproval ? 'YES' : 'NO').padStart(43)}║`);
+  console.log(`║ Requires ADR: ${(result.requiresADR ? 'YES' : 'NO').padStart(48)}║`);
+
+  if (result.warnings.length > 0) {
+    console.log('╠════════════════════════════════════════════════════════════════╣');
+    console.log('║ WARNINGS                                                       ║');
+    console.log('╠════════════════════════════════════════════════════════════════╣');
+    for (const warning of result.warnings) {
+      const chunks = warning.match(/.{1,62}/g) || [warning];
+      chunks.forEach(chunk => {
+        console.log(`║ ${chunk.padEnd(62)}║`);
+      });
+    }
+  }
+
+  console.log('╠════════════════════════════════════════════════════════════════╣');
+  console.log('║ LIMITS (from config)                                           ║');
+  console.log('╠════════════════════════════════════════════════════════════════╣');
+  console.log(`║ Free Tier Only: $${result.limits.freeTierOnly.toFixed(2).padStart(44)}║`);
+  console.log(`║ With Approval: $${result.limits.withApproval.toFixed(2).padStart(45)}║`);
+  console.log(`║ Requires ADR: $${result.limits.requiresADR.toFixed(2).padStart(46)}║`);
+  console.log('╚════════════════════════════════════════════════════════════════╝\n');
+}

package/src/commands/create-story.js

@@ -0,0 +1,283 @@
+/**
+ * MORPH-SPEC Story Creator
+ * Creates self-contained story files with auto-injected Dev Notes
+ * Inspired by BMAD Method story-driven development
+ */
+
+import fs from 'fs';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import { ensureDir, writeFile } from '../utils/file-copier.js';
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function readTemplate(templateName) {
+  const templatePath = path.join(process.cwd(), 'node_modules/@polymorphism-tech/morph-spec/content/.morph/templates', templateName);
+
+  // Fallback to local if in development
+  if (!fs.existsSync(templatePath)) {
+    const localPath = path.join(process.cwd(), `content/.morph/templates/${templateName}`);
+    if (fs.existsSync(localPath)) {
+      return fs.readFileSync(localPath, 'utf-8');
+    }
+    throw new Error(`Template not found: ${templateName}`);
+  }
+
+  return fs.readFileSync(templatePath, 'utf-8');
+}
+
+function readSpec(featureName) {
+  const specPath = path.join(process.cwd(), `.morph/project/outputs/${featureName}/spec.md`);
+  const shardedIndexPath = path.join(process.cwd(), `.morph/project/outputs/${featureName}/spec/index.md`);
+
+  // Try sharded spec first (BMAD pattern)
+  if (fs.existsSync(shardedIndexPath)) {
+    return { isSharded: true, indexPath: shardedIndexPath };
+  }
+
+  // Fallback to monolithic spec
+  if (fs.existsSync(specPath)) {
+    return { isSharded: false, content: fs.readFileSync(specPath, 'utf-8') };
+  }
+
+  throw new Error(`Spec not found for feature: ${featureName}`);
+}
+
+function extractContextFromSpec(specContent, sectionHeading) {
+  // Extract section content between ## heading and next ##
+  const regex = new RegExp(`## ${sectionHeading}\\s*([\\s\\S]*?)(?=\\n## |$)`, 'i');
+  const match = specContent.match(regex);
+  return match ? match[1].trim() : 'See spec.md for complete context';
+}
+
+function detectPatterns(tasks, specContent) {
+  const patterns = {
+    hasEntity: tasks.some(t => /entity|model|domain/i.test(t)),
+    hasService: tasks.some(t => /service|business|logic/i.test(t)),
+    hasComponent: tasks.some(t => /component|razor|blazor|ui/i.test(t)),
+    hasRepository: tasks.some(t => /repository|data|persistence/i.test(t)),
+    hasJob: tasks.some(t => /job|background|hangfire|scheduled/i.test(t)),
+    hasAI: tasks.some(t => /agent|ai|llm|semantic|rag/i.test(t)),
+    hasAzure: tasks.some(t => /bicep|azure|infra|deploy/i.test(t)),
+  };
+
+  return patterns;
+}
+
+function injectDevNotes(patterns, storyData) {
+  const notes = [];
+
+  // Entity pattern
+  if (patterns.hasEntity) {
+    notes.push('Use Primary Constructor (.NET 10 feature)');
+    notes.push('Follow entity pattern: .morph/project/standards/coding.md#entity-pattern');
+    notes.push('Navigation properties: configure in DbContext with Fluent API');
+  }
+
+  // Service pattern
+  if (patterns.hasService) {
+    notes.push('Service layer: implement interface-first (IXService → XService)');
+    notes.push('Dependency injection: register in Program.cs as Scoped');
+    notes.push('Error handling: use Result<T> pattern from standards/architecture.md');
+  }
+
+  // Blazor component
+  if (patterns.hasComponent) {
+    notes.push('UI Library: Fluent UI Blazor (see .morph/project/standards/ui.md)');
+    notes.push('Design System: use CSS variables from wwwroot/css/design-system.css');
+    notes.push('State management: @inject for services, [Parameter] for props');
+  }
+
+  // Repository pattern
+  if (patterns.hasRepository) {
+    notes.push('Repository pattern: IRepository<T> generic base');
+    notes.push('EF Core: use AsNoTracking() for read-only queries');
+    notes.push('Transactions: wrap in DbContext.Database.BeginTransactionAsync()');
+  }
+
+  // Background job
+  if (patterns.hasJob) {
+    notes.push('Hangfire: implement IJob interface, register in HangfireConfig.cs');
+    notes.push('Retry policy: use [AutomaticRetry(Attempts = 3)]');
+    notes.push('Logging: inject ILogger<TJob> for monitoring');
+  }
+
+  // AI/Agent
+  if (patterns.hasAI) {
+    notes.push('Microsoft Agent Framework: use AgentBuilder (not Semantic Kernel)');
+    notes.push('Prompts: store in /prompts/{agent-name}.md');
+    notes.push('Vector search: use EF Core 10 Vector Search (see standards/vector-search-rag.md)');
+  }
+
+  // Azure/IaC
+  if (patterns.hasAzure) {
+    notes.push('Infrastructure as Code: ALWAYS use Bicep (never portal)');
+    notes.push('Cost validation: run morph-spec cost before commit');
+    notes.push('Deployment: Azure Container Apps (not App Service)');
+  }
+
+  // Add spec reference
+  if (storyData.specShard) {
+    notes.push(`Spec reference: .morph/project/outputs/${storyData.featureName}/spec/${storyData.specShard}.md`);
+  } else {
+    notes.push(`Spec reference: .morph/project/outputs/${storyData.featureName}/spec.md`);
+  }
+
+  return notes;
+}
+
+function renderStory(template, data) {
+  let rendered = template;
+
+  // Simple placeholder replacement (non-Mustache for simplicity)
+  const replacements = {
+    '{{STORY_ID}}': data.storyId || 'STORY-XXX',
+    '{{STORY_TITLE}}': data.storyTitle || 'Story Title',
+    '{{FEATURE_NAME}}': data.featureName || 'feature-name',
+    '{{FEATURE_NAME_TITLE}}': data.featureNameTitle || 'Feature Name',
+    '{{EPIC_NAME}}': data.epicName || 'Epic Name',
+    '{{DATE}}': new Date().toISOString().split('T')[0],
+    '{{STORY_CONTEXT}}': data.context || 'Context not provided',
+    '{{SPEC_SHARD}}': data.specShard || 'spec',
+    '{{EFFORT}}': data.effort || '1 day',
+    '{{CODING_PATTERN}}': data.codingPattern || 'general',
+    '{{ARCH_PATTERN}}': data.archPattern || 'clean-architecture',
+    '{{STATUS}}': 'Ready',
+    '{{CREATED_DATE}}': new Date().toISOString().split('T')[0],
+    '{{ADDITIONAL_NOTES}}': data.additionalNotes || '',
+  };
+
+  for (const [placeholder, value] of Object.entries(replacements)) {
+    rendered = rendered.replaceAll(placeholder, value);
+  }
+
+  // Handle arrays (tasks, dev notes, acceptance criteria)
+  if (data.tasks && data.tasks.length > 0) {
+    const tasksSection = data.tasks.map(t => `- [ ] ${t}`).join('\n');
+    rendered = rendered.replace(/{{#TASKS}}[\s\S]*?{{\/TASKS}}/g, tasksSection);
+  } else {
+    rendered = rendered.replace(/{{#TASKS}}[\s\S]*?{{\/TASKS}}/g, '- [ ] Task 1\n- [ ] Task 2');
+  }
+
+  if (data.devNotes && data.devNotes.length > 0) {
+    const devNotesSection = data.devNotes.map(n => `- ${n}`).join('\n');
+    rendered = rendered.replace(/{{#DEV_NOTES}}[\s\S]*?{{\/DEV_NOTES}}/g, devNotesSection);
+  } else {
+    rendered = rendered.replace(/{{#DEV_NOTES}}[\s\S]*?{{\/DEV_NOTES}}/g, '- Follow standards in .morph/project/standards/');
+  }
+
+  if (data.acceptanceCriteria && data.acceptanceCriteria.length > 0) {
+    const acSection = data.acceptanceCriteria.map(ac =>
+      `- [ ] **GIVEN** ${ac.given} **WHEN** ${ac.when} **THEN** ${ac.then}`
+    ).join('\n');
+    rendered = rendered.replace(/{{#ACCEPTANCE_CRITERIA}}[\s\S]*?{{\/ACCEPTANCE_CRITERIA}}/g, acSection);
+  } else {
+    rendered = rendered.replace(/{{#ACCEPTANCE_CRITERIA}}[\s\S]*?{{\/ACCEPTANCE_CRITERIA}}/g,
+      '- [ ] **GIVEN** [condition] **WHEN** [action] **THEN** [result]');
+  }
+
+  // Clean up remaining Mustache sections (empty arrays)
+  rendered = rendered.replace(/{{#\w+}}[\s\S]*?{{\/\w+}}/g, '');
+
+  return rendered;
+}
+
+function toTitleCase(str) {
+  return str
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+// ============================================================================
+// Command Function
+// ============================================================================
+
+export async function createStoryCommand(feature, storyId, options) {
+  logger.header('MORPH-SPEC Story Creator');
+  logger.dim(`Feature: ${feature}`);
+  logger.dim(`Story ID: ${storyId}`);
+  logger.blank();
+
+  const spinner = ora('Creating story...').start();
+
+  try {
+    // Read template
+    const template = readTemplate('story.md');
+
+    // Read spec (detect if sharded)
+    const spec = readSpec(feature);
+
+    // Build story data
+    const storyData = {
+      featureName: feature,
+      featureNameTitle: toTitleCase(feature),
+      storyId,
+      storyTitle: options.title || 'Story Title',
+      epicName: options.epic || toTitleCase(feature),
+      context: options.context || (spec.isSharded
+        ? 'See sharded spec for complete context'
+        : extractContextFromSpec(spec.content, 'Overview')),
+      specShard: spec.isSharded ? 'index' : null,
+      tasks: options.tasks ? options.tasks.split(',').map(t => t.trim()) : ['Task 1', 'Task 2'],
+      effort: '1 day',
+      additionalNotes: '',
+    };
+
+    // Detect patterns and inject Dev Notes
+    const patterns = detectPatterns(storyData.tasks, spec.content || '');
+    storyData.devNotes = injectDevNotes(patterns, storyData);
+
+    // Default acceptance criteria
+    storyData.acceptanceCriteria = [
+      { given: '[condition]', when: '[action]', then: '[expected result]' },
+    ];
+
+    // Render story
+    const renderedStory = renderStory(template, storyData);
+
+    // Output
+    const outputDir = path.join(process.cwd(), `.morph/project/outputs/${feature}/stories`);
+    const outputPath = path.join(outputDir, `${storyId}.md`);
+
+    if (options.dryRun) {
+      spinner.info('Dry run - preview only');
+      logger.blank();
+      console.log(renderedStory);
+      logger.blank();
+      logger.dim(`Would be written to: ${outputPath}`);
+    } else {
+      // Ensure directory exists
+      await ensureDir(outputDir);
+
+      // Write file
+      await writeFile(outputPath, renderedStory);
+
+      spinner.succeed('Story created!');
+      logger.blank();
+
+      logger.success(`Story file: ${chalk.cyan(outputPath)}`);
+      logger.blank();
+
+      logger.header('Dev Notes Auto-Injected:');
+      storyData.devNotes.forEach(note => logger.dim(`  - ${note}`));
+      logger.blank();
+
+      logger.header('Next Steps:');
+      logger.dim('  1. Review and customize story file');
+      logger.dim('  2. Run in fresh Claude session: /dev → implement story');
+      logger.dim('  3. Dev adds implementation notes');
+      logger.dim('  4. QA reviews and adds QA notes');
+      logger.blank();
+    }
+
+  } catch (error) {
+    spinner.fail('Failed to create story');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}

package/src/commands/detect.js

@@ -0,0 +1,104 @@
+import { join } from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import { logger } from '../utils/logger.js';
+import { detectProject, getDetectionSummary } from '../../detectors/index.js';
+import { ensureDir, writeFile } from '../utils/file-copier.js';
+
+export async function detectCommand(options) {
+  const targetPath = options.path || process.cwd();
+
+  logger.header('MORPH-SPEC Project Detection');
+  logger.dim(`Analyzing: ${targetPath}`);
+  logger.blank();
+
+  const spinner = ora('Detecting project structure...').start();
+
+  try {
+    // Run detection
+    const results = await detectProject(targetPath, {
+      structure: true,
+      config: true,
+      conversation: true,
+      generateStandards: true
+    });
+
+    spinner.succeed('Detection complete!');
+    logger.blank();
+
+    // Display summary
+    logger.header('Detection Results');
+    logger.blank();
+
+    // Stack
+    logger.info(`Stack: ${chalk.cyan(results.structure.stack)}`);
+    logger.info(`Architecture: ${chalk.cyan(results.structure.architecture)}`);
+    if (results.structure.uiLibrary) {
+      logger.info(`UI Library: ${chalk.cyan(results.structure.uiLibrary)}`);
+    }
+    logger.blank();
+
+    // Technologies
+    if (results.config.technologies.length > 0) {
+      logger.header('Technologies:');
+      results.config.technologies.forEach(tech => {
+        logger.dim(`  - ${tech}`);
+      });
+      logger.blank();
+    }
+
+    // Patterns
+    if (results.structure.patterns.length > 0) {
+      logger.header('Patterns:');
+      results.structure.patterns.forEach(pattern => {
+        logger.dim(`  - ${pattern}`);
+      });
+      logger.blank();
+    }
+
+    // Recommendations
+    if (results.inferred.recommendations.length > 0) {
+      logger.header('Recommendations:');
+      results.inferred.recommendations.forEach(rec => {
+        logger.warn(`  ⚠ ${rec}`);
+      });
+      logger.blank();
+    }
+
+    // Save results if requested
+    if (options.save !== false) {
+      spinner.start('Saving detection results...');
+
+      const outputDir = join(targetPath, '.morph', 'project', 'context');
+      await ensureDir(outputDir);
+
+      // Save detection log
+      const logPath = join(outputDir, 'detection-log.md');
+      const summary = getDetectionSummary(results);
+      await writeFile(logPath, summary);
+
+      // Save inferred standards
+      const standardsDir = join(targetPath, '.morph', 'project', 'standards');
+      await ensureDir(standardsDir);
+
+      const standardsPath = join(standardsDir, 'inferred.md');
+      await writeFile(standardsPath, results.inferred.markdown);
+
+      spinner.succeed('Results saved!');
+      logger.dim(`  - ${logPath}`);
+      logger.dim(`  - ${standardsPath}`);
+    }
+
+    // Verbose output
+    if (options.verbose) {
+      logger.blank();
+      logger.header('Detailed Results (JSON):');
+      console.log(JSON.stringify(results, null, 2));
+    }
+
+  } catch (error) {
+    spinner.fail('Detection failed');
+    logger.error(error.message);
+    process.exit(1);
+  }
+}