@polymorphism-tech/morph-spec 1.0.4 → 2.1.0

package/content/README.md

@@ -0,0 +1,79 @@
+# MORPH-SPEC Content - Projeto Exemplo
+
+Este diretório contém um **projeto exemplo** mostrando como usar o framework MORPH-SPEC em um projeto .NET/Blazor.
+
+> 📘 **Nota**: Este não é o código do framework, apenas um exemplo de uso.
+
+---
+
+## 📁 Estrutura
+
+```
+content/
+├── .morph/                    # Configuração MORPH do projeto exemplo
+│   ├── project/               # Context e outputs do projeto
+│   │   ├── context/
+│   │   ├── standards/
+│   │   └── outputs/
+│   └── config.json            # Link para framework global
+│
+├── CLAUDE.md                  # Instruções para Claude Code
+└── src/                       # (futuro) Código exemplo
+```
+
+---
+
+## 🎯 Objetivo
+
+Este exemplo demonstra:
+
+1. Como inicializar MORPH em um projeto
+2. Estrutura de `.morph/project/`
+3. Como Claude Code usa o framework
+4. Exemplos de features implementadas com MORPH
+
+---
+
+## 🚀 Como Usar Este Exemplo
+
+### 1. Instalar MORPH globalmente
+
+```bash
+npm install -g @polymorphism-tech/morph-spec
+```
+
+### 2. Ver estrutura detectada
+
+```bash
+cd content/
+morph-spec detect --verbose
+```
+
+### 3. Inicializar em seu próprio projeto
+
+```bash
+cd seu-projeto/
+morph-spec init
+```
+
+---
+
+## 📚 Documentação
+
+- **Framework**: Veja `../framework/` para standards e templates
+- **Docs**: Veja `../docs/` para guias completos
+- **CLI**: Execute `morph-spec --help`
+
+---
+
+## ⚠️ Importante
+
+Este é um **exemplo read-only**. Para criar seu próprio projeto:
+
+1. NÃO copie este diretório
+2. Execute `morph-spec init` no seu projeto
+3. O framework será linkado automaticamente
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*

package/detectors/config-detector.js

@@ -0,0 +1,223 @@
+/**
+ * Config Detector - Reads configuration files to extract technologies, versions, and dependencies
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { glob } from 'glob';
+
+/**
+ * Detect project configuration
+ * @param {string} projectPath - Project root path
+ * @returns {Promise<Object>} Configuration detection results
+ */
+export async function detectConfig(projectPath) {
+  const result = {
+    language: 'unknown',
+    version: null,
+    packageManager: 'unknown',
+    dependencies: [],
+    technologies: [],
+    auth: null,
+    database: null,
+    hosting: null
+  };
+
+  // Detect .NET projects
+  const dotnetConfig = await detectDotNet(projectPath);
+  if (dotnetConfig) {
+    Object.assign(result, dotnetConfig);
+    return result;
+  }
+
+  // Detect Node.js projects
+  const nodeConfig = await detectNode(projectPath);
+  if (nodeConfig) {
+    Object.assign(result, nodeConfig);
+    return result;
+  }
+
+  return result;
+}
+
+/**
+ * Detect .NET configuration
+ */
+async function detectDotNet(projectPath) {
+  const programCs = join(projectPath, 'Program.cs');
+  const csprojFiles = await glob('**/*.csproj', { cwd: projectPath });
+
+  if (!existsSync(programCs) && csprojFiles.length === 0) {
+    return null;
+  }
+
+  const config = {
+    language: 'csharp',
+    version: null,
+    packageManager: 'dotnet',
+    dependencies: [],
+    technologies: [],
+    auth: null,
+    database: null,
+    hosting: null
+  };
+
+  // Read Program.cs
+  if (existsSync(programCs)) {
+    const content = readFileSync(programCs, 'utf8');
+
+    // Detect .NET version
+    if (content.includes('WebApplication.CreateBuilder') || content.includes('.NET')) {
+      config.version = detectDotNetVersion(content);
+    }
+
+    // Detect technologies from Program.cs
+    config.technologies = detectTechnologiesFromProgramCs(content);
+    config.auth = detectAuthMethod(content);
+    config.database = detectDatabase(content);
+    config.hosting = detectHosting(content);
+  }
+
+  // Read .csproj files
+  for (const csprojFile of csprojFiles.slice(0, 3)) { // Read first 3 csproj files
+    const csprojPath = join(projectPath, csprojFile);
+    const content = readFileSync(csprojPath, 'utf8');
+
+    config.dependencies.push(...extractNuGetPackages(content));
+  }
+
+  // Remove duplicates
+  config.dependencies = [...new Set(config.dependencies)];
+  config.technologies = [...new Set(config.technologies)];
+
+  return config;
+}
+
+/**
+ * Detect Node.js configuration
+ */
+async function detectNode(projectPath) {
+  const packageJsonPath = join(projectPath, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+
+  const config = {
+    language: 'javascript',
+    version: packageJson.engines?.node || null,
+    packageManager: existsSync(join(projectPath, 'yarn.lock')) ? 'yarn' :
+                    existsSync(join(projectPath, 'pnpm-lock.yaml')) ? 'pnpm' : 'npm',
+    dependencies: [],
+    technologies: [],
+    auth: null,
+    database: null,
+    hosting: null
+  };
+
+  // Extract dependencies
+  const allDeps = {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies
+  };
+
+  config.dependencies = Object.keys(allDeps);
+
+  // Detect technologies
+  if (allDeps['next']) config.technologies.push('Next.js');
+  if (allDeps['react']) config.technologies.push('React');
+  if (allDeps['@clerk/nextjs']) config.auth = 'Clerk';
+  if (allDeps['prisma']) config.database = 'Prisma';
+
+  return config;
+}
+
+/**
+ * Detect .NET version from Program.cs
+ */
+function detectDotNetVersion(content) {
+  if (content.includes('.NET 10') || content.includes('net10.0')) return '.NET 10';
+  if (content.includes('.NET 9') || content.includes('net9.0')) return '.NET 9';
+  if (content.includes('.NET 8') || content.includes('net8.0')) return '.NET 8';
+  return 'unknown';
+}
+
+/**
+ * Detect technologies from Program.cs
+ */
+function detectTechnologiesFromProgramCs(content) {
+  const techs = [];
+
+  if (content.includes('AddBlazor') || content.includes('MapBlazorHub')) {
+    techs.push('Blazor Server');
+  }
+
+  if (content.includes('AddHangfire')) {
+    techs.push('Hangfire');
+  }
+
+  if (content.includes('IChatClient') || content.includes('Microsoft.Agents')) {
+    techs.push('Microsoft Agent Framework');
+  }
+
+  if (content.includes('AddDbContext') || content.includes('UseSqlServer')) {
+    techs.push('Entity Framework Core');
+  }
+
+  if (content.includes('AddFluentUIComponents') || content.includes('FluentUI')) {
+    techs.push('Fluent UI Blazor');
+  }
+
+  if (content.includes('AddMudServices') || content.includes('MudBlazor')) {
+    techs.push('MudBlazor');
+  }
+
+  return techs;
+}
+
+/**
+ * Detect authentication method
+ */
+function detectAuthMethod(content) {
+  if (content.includes('AddClerk') || content.includes('Clerk')) return 'Clerk';
+  if (content.includes('AddMicrosoftIdentity') || content.includes('Entra')) return 'Microsoft Entra';
+  if (content.includes('AddAuthentication')) return 'ASP.NET Identity';
+  return null;
+}
+
+/**
+ * Detect database
+ */
+function detectDatabase(content) {
+  if (content.includes('UseSqlServer')) return 'SQL Server';
+  if (content.includes('UsePostgres')) return 'PostgreSQL';
+  if (content.includes('UseSqlite')) return 'SQLite';
+  if (content.includes('UseCosmos')) return 'Cosmos DB';
+  return null;
+}
+
+/**
+ * Detect hosting platform
+ */
+function detectHosting(content) {
+  if (content.includes('Azure') || content.includes('AddAzure')) return 'Azure';
+  if (content.includes('AWS')) return 'AWS';
+  return null;
+}
+
+/**
+ * Extract NuGet packages from .csproj
+ */
+function extractNuGetPackages(csprojContent) {
+  const packages = [];
+  const regex = /<PackageReference\s+Include="([^"]+)"/g;
+  let match;
+
+  while ((match = regex.exec(csprojContent)) !== null) {
+    packages.push(match[1]);
+  }
+
+  return packages;
+}

package/detectors/conversation-analyzer.js

@@ -0,0 +1,163 @@
+/**
+ * Conversation Analyzer - Analyzes Claude Code conversation history for user preferences
+ *
+ * Note: This is a basic implementation. Full conversation analysis would require
+ * access to Claude Code's message history API or local cache.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Analyze conversation history
+ * @param {string} projectPath - Project root path
+ * @returns {Promise<Object>} Conversation analysis results
+ */
+export async function analyzeConversation(projectPath) {
+  const result = {
+    preferences: {},
+    decisions: [],
+    patterns: [],
+    available: false
+  };
+
+  // Check if .morph/project/context exists (past decisions)
+  const contextPath = join(projectPath, '.morph', 'project', 'context');
+  if (existsSync(contextPath)) {
+    result.available = true;
+
+    // Read decisions-history.md if exists
+    const decisionsFile = join(contextPath, 'decisions-history.md');
+    if (existsSync(decisionsFile)) {
+      const content = readFileSync(decisionsFile, 'utf8');
+      result.decisions = extractDecisions(content);
+    }
+  }
+
+  // Check .morph/project/outputs/*/decisions.md
+  const outputsPath = join(projectPath, '.morph', 'project', 'outputs');
+  if (existsSync(outputsPath)) {
+    const { readdirSync } = await import('fs');
+    const features = readdirSync(outputsPath, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+
+    for (const feature of features) {
+      const decisionsFile = join(outputsPath, feature, 'decisions.md');
+      if (existsSync(decisionsFile)) {
+        const content = readFileSync(decisionsFile, 'utf8');
+        result.decisions.push(...extractDecisions(content));
+      }
+    }
+  }
+
+  // Extract patterns from decisions
+  result.patterns = inferPatternsFromDecisions(result.decisions);
+
+  // Extract preferences
+  result.preferences = extractPreferences(result.decisions);
+
+  return result;
+}
+
+/**
+ * Extract decisions from markdown
+ */
+function extractDecisions(markdown) {
+  const decisions = [];
+  const lines = markdown.split('\n');
+
+  let currentDecision = null;
+
+  for (const line of lines) {
+    // Look for decision headings
+    if (line.match(/^##\s+Decision/i) || line.match(/^###\s+ADR/i)) {
+      if (currentDecision) {
+        decisions.push(currentDecision);
+      }
+      currentDecision = { text: '', category: 'unknown', confidence: 0.5 };
+    }
+
+    if (currentDecision) {
+      currentDecision.text += line + '\n';
+
+      // Categorize
+      if (line.includes('UI') || line.includes('component') || line.includes('Fluent') || line.includes('Mud')) {
+        currentDecision.category = 'ui-ux';
+        currentDecision.confidence = 0.8;
+      } else if (line.includes('pattern') || line.includes('architecture') || line.includes('CQRS')) {
+        currentDecision.category = 'architecture';
+        currentDecision.confidence = 0.8;
+      } else if (line.includes('Azure') || line.includes('Container') || line.includes('deployment')) {
+        currentDecision.category = 'azure';
+        currentDecision.confidence = 0.8;
+      } else if (line.includes('class') || line.includes('method') || line.includes('naming')) {
+        currentDecision.category = 'coding';
+        currentDecision.confidence = 0.8;
+      }
+    }
+  }
+
+  if (currentDecision) {
+    decisions.push(currentDecision);
+  }
+
+  return decisions;
+}
+
+/**
+ * Infer patterns from decisions
+ */
+function inferPatternsFromDecisions(decisions) {
+  const patterns = [];
+
+  for (const decision of decisions) {
+    const text = decision.text.toLowerCase();
+
+    if (text.includes('always use') || text.includes('sempre usar')) {
+      patterns.push(`Pattern: ${decision.text.split('\n')[0].substring(0, 60)}...`);
+    }
+
+    if (text.includes('never') || text.includes('nunca')) {
+      patterns.push(`Anti-pattern: ${decision.text.split('\n')[0].substring(0, 60)}...`);
+    }
+  }
+
+  return patterns;
+}
+
+/**
+ * Extract user preferences
+ */
+function extractPreferences(decisions) {
+  const preferences = {
+    uiLibrary: null,
+    architecture: null,
+    testing: null,
+    deployment: null
+  };
+
+  for (const decision of decisions) {
+    const text = decision.text.toLowerCase();
+
+    if (text.includes('fluent ui') && !text.includes('not')) {
+      preferences.uiLibrary = 'Fluent UI';
+    } else if (text.includes('mudblazor') && !text.includes('not')) {
+      preferences.uiLibrary = 'MudBlazor';
+    }
+
+    if (text.includes('clean architecture')) {
+      preferences.architecture = 'Clean Architecture';
+    } else if (text.includes('cqrs')) {
+      preferences.architecture = 'CQRS';
+    }
+
+    if (text.includes('container apps')) {
+      preferences.deployment = 'Azure Container Apps';
+    } else if (text.includes('app service')) {
+      preferences.deployment = 'Azure App Service';
+    }
+  }
+
+  return preferences;
+}

package/detectors/index.js

@@ -0,0 +1,84 @@
+/**
+ * MORPH-SPEC Detectors - Main Orchestrator
+ *
+ * Coordinates all detection modules to build a complete picture of the project.
+ */
+
+import { detectStructure } from './structure-detector.js';
+import { detectConfig } from './config-detector.js';
+import { analyzeConversation } from './conversation-analyzer.js';
+import { generateStandards } from './standards-generator.js';
+
+/**
+ * Main detection orchestrator
+ * @param {string} projectPath - Path to project root
+ * @param {Object} options - Detection options
+ * @returns {Promise<Object>} Detection results
+ */
+export async function detectProject(projectPath, options = {}) {
+  const results = {
+    path: projectPath,
+    timestamp: new Date().toISOString(),
+    structure: null,
+    config: null,
+    conversation: null,
+    inferred: null
+  };
+
+  try {
+    // 1. Detect structure (stack, architecture, patterns)
+    if (options.structure !== false) {
+      results.structure = await detectStructure(projectPath);
+    }
+
+    // 2. Detect config (technologies, dependencies, versions)
+    if (options.config !== false) {
+      results.config = await detectConfig(projectPath);
+    }
+
+    // 3. Analyze conversation history (if available)
+    if (options.conversation !== false) {
+      results.conversation = await analyzeConversation(projectPath);
+    }
+
+    // 4. Generate inferred standards
+    if (options.generateStandards !== false) {
+      results.inferred = await generateStandards(results);
+    }
+
+    return results;
+  } catch (error) {
+    throw new Error(`Detection failed: ${error.message}`);
+  }
+}
+
+/**
+ * Get detection summary
+ * @param {Object} results - Detection results
+ * @returns {string} Human-readable summary
+ */
+export function getDetectionSummary(results) {
+  const { structure, config } = results;
+
+  const lines = [
+    '## Detection Summary',
+    '',
+    '### Stack',
+    `- **Type**: ${structure?.stack || 'unknown'}`,
+    `- **Architecture**: ${structure?.architecture || 'unknown'}`,
+    `- **UI Library**: ${structure?.uiLibrary || 'none'}`,
+    '',
+    '### Technologies',
+    `- **Language**: ${config?.language || 'unknown'}`,
+    `- **Version**: ${config?.version || 'unknown'}`,
+    `- **Package Manager**: ${config?.packageManager || 'unknown'}`,
+    '',
+    '### Patterns Detected',
+    ...(structure?.patterns || []).map(p => `- ${p}`),
+    '',
+    '### Recommendations',
+    ...(results.inferred?.recommendations || []).map(r => `- ${r}`)
+  ];
+
+  return lines.join('\n');
+}