@polymorphism-tech/morph-spec 4.3.1 → 4.3.3

package/bin/morph-spec.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { program } from 'commander';
 import chalk from 'chalk';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "4.3.1",
+  "version": "4.3.3",
   "description": "MORPH-SPEC: AI-First development framework with validation pipeline and multi-stack support",
   "keywords": [
     "claude-code",
@@ -48,6 +48,7 @@
     "docs:serve": "npx http-server docs/api -p 8080 -o"
   },
   "dependencies": {
+    "@polymorphism-tech/morph-spec": "^4.3.1",
     "ajv": "^8.12.0",
     "ajv-formats": "^3.0.1",
     "chalk": "^5.3.0",

package/src/commands/project/doctor.js

@@ -391,24 +391,25 @@ export async function doctorCommand(options = {}) {
     hasErrors = true;
   }
 
-  // Check standards
+  // Check standards (either in project .morph/standards/ or in framework package)
   const standardsPath = join(morphPath, 'standards');
+  const frameworkStdsRoot = join(import.meta.dirname, '..', '..', '..', 'framework', 'standards');
   if (await pathExists(standardsPath)) {
-    const codingStd = join(standardsPath, 'coding.md');
-    const archStd = join(standardsPath, 'architecture.md');
-    const azureStd = join(standardsPath, 'azure.md');
-
-    const hasAll = await Promise.all([
-      pathExists(codingStd),
-      pathExists(archStd),
-      pathExists(azureStd)
-    ]).then(results => results.every(Boolean));
-
-    if (hasAll) {
+    // Check for core standards in hierarchy (copied by init) or flat layout
+    const codingStd = await pathExists(join(standardsPath, 'core', 'coding.md')) ||
+                      await pathExists(join(standardsPath, 'coding.md'));
+    const archStd   = await pathExists(join(standardsPath, 'core', 'architecture.md')) ||
+                      await pathExists(join(standardsPath, 'architecture.md'));
+    if (codingStd && archStd) {
       checks.push({ name: 'standards/', status: 'ok' });
     } else {
-      checks.push({ name: 'standards/', status: 'warn', msg: 'some files missing' });
+      checks.push({ name: 'standards/', status: 'warn', msg: 'core standards missing — run morph-spec init' });
+      hasWarnings = true;
     }
+  } else if (await pathExists(frameworkStdsRoot)) {
+    // Framework package has standards (dev/global install mode)
+    checks.push({ name: 'standards/', status: 'warn', msg: 'not installed in project (run morph-spec init)' });
+    hasWarnings = true;
   } else {
     checks.push({ name: 'standards/', status: 'missing' });
     hasErrors = true;
@@ -487,13 +488,18 @@ export async function doctorCommand(options = {}) {
     hasWarnings = true;
   }
 
-  // Check key templates exist
-  const keyTemplates = ['proposal.md', 'spec.md', 'tasks.md', 'decisions.md'];
+  // Check key templates exist (in framework package, not project copy)
+  const frameworkTemplatesRoot = join(import.meta.dirname, '..', '..', '..', 'framework', 'templates');
+  const keyTemplates = [
+    { name: 'proposal.md', path: join(frameworkTemplatesRoot, 'docs', 'proposal.md') },
+    { name: 'spec.md', path: join(frameworkTemplatesRoot, 'docs', 'spec.md') },
+    { name: 'tasks.md', path: join(frameworkTemplatesRoot, 'feature', 'tasks.md') },
+    { name: 'decisions.md', path: join(frameworkTemplatesRoot, 'feature', 'decisions.md') }
+  ];
   const missingTemplates = [];
   for (const template of keyTemplates) {
-    const templatePath = join(templatesPath, template);
-    if (!(await pathExists(templatePath))) {
-      missingTemplates.push(template);
+    if (!(await pathExists(template.path))) {
+      missingTemplates.push(template.name);
     }
   }
 

package/src/commands/project/init.js

@@ -112,8 +112,10 @@ Run \`morph-spec detect\` to analyze your project.
     const contentDir = getContentDir();
     const templatesSrc = join(contentDir, '.morph', 'templates');
     const templatesDest = join(morphPath, 'templates');
+    let templatesCopied = false;
     if (await pathExists(templatesSrc)) {
       await copyDirectory(templatesSrc, templatesDest);
+      templatesCopied = true;
     }
 
     // 6. Copy standards from content (stack-specific)
@@ -126,7 +128,7 @@ Run \`morph-spec detect\` to analyze your project.
 
     // 6b. Copy framework standards hierarchy (universal standards)
     spinner.text = 'Copying framework standards hierarchy...';
-    const frameworkStandardsSrc = join(import.meta.dirname, '..', '..', 'framework', 'standards');
+    const frameworkStandardsSrc = join(import.meta.dirname, '..', '..', '..', 'framework', 'standards');
     const frameworkStandardsDest = join(morphPath, 'standards');
     if (await pathExists(frameworkStandardsSrc)) {
       // Copy entire hierarchy (core/, backend/, frontend/, infrastructure/)
@@ -134,9 +136,9 @@ Run \`morph-spec detect\` to analyze your project.
       logger.dim('  ✓ Copied framework standards: core/, backend/, frontend/, infrastructure/');
     }
 
-    // 7. Copy agents.json
+    // 7. Copy agents.json (sourced from framework root .morph/config/ — canonical single source of truth)
     spinner.text = 'Copying agents configuration...';
-    const agentsSrc = join(contentDir, '.morph', 'config', 'agents.json');
+    const agentsSrc = join(import.meta.dirname, '..', '..', '..', '.morph', 'config', 'agents.json');
     const agentsDest = join(configDir, 'agents.json');
     if (await pathExists(agentsSrc)) {
       await copyFile(agentsSrc, agentsDest);
@@ -163,6 +165,7 @@ Run \`morph-spec detect\` to analyze your project.
 
     let symlinkCount = 0;
     let copyCount = 0;
+    let commandsCopied = false;
 
     if (await pathExists(claudeSrc)) {
       // Copy commands directory (slash commands)
@@ -170,6 +173,9 @@ Run \`morph-spec detect\` to analyze your project.
       const commandsDest = join(claudeDest, 'commands');
       if (await pathExists(commandsSrc)) {
         await copyDirectory(commandsSrc, commandsDest);
+        commandsCopied = true;
+      } else {
+        logger.warn('  ⚠ .claude/commands/ source missing — commands not installed');
       }
 
       // Create directory links for skill categories (or copy if linking fails)
@@ -254,9 +260,13 @@ Run \`morph-spec detect\` to analyze your project.
     logger.dim(`  ✓ CLAUDE.md`);
     logger.dim(`  ✓ .morph/config/ (config.json, agents.json, azure-pricing.json)`);
     logger.dim(`  ✓ .morph/standards/ (coding.md, architecture.md, azure.md, ...)`);
-    logger.dim(`  ✓ .morph/templates/ (Bicep, integrations, saas, ...)`);
+    if (templatesCopied) {
+      logger.dim(`  ✓ .morph/templates/ (Bicep, integrations, saas, ...)`);
+    }
     logger.dim(`  ✓ .morph/project/ (context, standards, outputs)`);
-    logger.dim(`  ✓ .claude/commands/ (slash commands)`);
+    if (commandsCopied) {
+      logger.dim(`  ✓ .claude/commands/ (slash commands)`);
+    }
     logger.dim(`  ✓ .claude/settings.local.json (agent-teams hooks)`);
 
     if (symlinkCount > 0) {

package/src/commands/project/update.js

@@ -112,9 +112,9 @@ export async function updateCommand(options) {
       await copyDirectory(standardsSrc, standardsDest);
     }
 
-    // Update agents.json
+    // Update agents.json (sourced from framework root .morph/config/ — canonical single source of truth)
     updateSpinner.text = 'Updating agents configuration...';
-    const agentsSrc = join(contentDir, '.morph', 'config', 'agents.json');
+    const agentsSrc = join(__dirname, '..', '..', '..', '.morph', 'config', 'agents.json');
     const agentsDest = join(morphPath, 'config', 'agents.json');
     if (await pathExists(agentsSrc)) {
       await copyDirectory(agentsSrc, agentsDest);
@@ -125,12 +125,14 @@ export async function updateCommand(options) {
     updateSpinner.text = 'Updating Claude commands and skills...';
     const claudeSrc = join(__dirname, '..', '..', '..', '.claude');
     const claudeDest = join(targetPath, '.claude');
+    let claudeUpdated = false;
     if (await pathExists(claudeSrc)) {
       // Copy commands (always copy, these are small)
       const commandsSrc = join(claudeSrc, 'commands');
       const commandsDest = join(claudeDest, 'commands');
       if (await pathExists(commandsSrc)) {
         await copyDirectory(commandsSrc, commandsDest);
+        claudeUpdated = true;
 
         // Clean up stale command files moved to skills/workflows/ in v2.4+
         const staleCommands = [
@@ -143,6 +145,8 @@ export async function updateCommand(options) {
             await fs.remove(stalePath);
           }
         }
+      } else {
+        logger.warn('  ⚠ .claude/commands/ source missing — commands not updated');
       }
 
       // Update skills using directory links per category
@@ -200,7 +204,7 @@ export async function updateCommand(options) {
     if (updateTemplates) logger.dim('  ✓ .morph/templates/');
     if (updateStandards) logger.dim('  ✓ .morph/standards/');
     logger.dim('  ✓ .morph/config/agents.json');
-    logger.dim('  ✓ .claude/commands/ and .claude/skills/');
+    if (claudeUpdated) logger.dim('  ✓ .claude/commands/ and .claude/skills/');
     logger.dim('  ✓ .claude/settings.local.json (agent-teams hooks)');
     logger.dim('  ✓ CLAUDE.md');
     logger.blank();

package/src/commands/state/state.js

@@ -3,6 +3,8 @@
  * CLI wrapper for state management operations
  */
 
+import { join } from 'path';
+import { readFileSync, existsSync } from 'fs';
 import ora from 'ora';
 import chalk from 'chalk';
 import { logger } from '../../utils/logger.js';
@@ -77,10 +79,30 @@ async function initCommand(options) {
 
     const spinner = ora('Initializing state.json...').start();
 
+    // Read project name and stack from config.json if not provided via options
+    let projectName = options.project;
+    let projectType = options.type;
+    if (!projectName || !projectType) {
+      const configPath = join(process.cwd(), '.morph', 'config', 'config.json');
+      if (existsSync(configPath)) {
+        try {
+          const config = JSON.parse(readFileSync(configPath, 'utf8'));
+          projectName = projectName || config.project?.name || 'unknown';
+          projectType = projectType || config.project?.stack || 'unknown';
+        } catch {
+          projectName = projectName || 'unknown';
+          projectType = projectType || 'unknown';
+        }
+      } else {
+        projectName = projectName || 'unknown';
+        projectType = projectType || 'unknown';
+      }
+    }
+
     StateManager.initState({
       force: options.force,
-      projectName: options.project || '{PROJECT_NAME}',
-      projectType: options.type || 'blazor-server'
+      projectName,
+      projectType
     });
 
     spinner.succeed('State initialized!');

package/src/core/templates/template-registry.js

@@ -36,7 +36,7 @@ export function loadTemplateRegistry(projectPath = null) {
   // Default to framework registry
   const registryPath = projectPath
     ? join(projectPath, 'framework/templates/REGISTRY.json')
-    : join(__dirname, '../../framework/templates/REGISTRY.json');
+    : join(__dirname, '../../../framework/templates/REGISTRY.json');
 
   if (!existsSync(registryPath)) {
     throw new Error(`Template registry not found: ${registryPath}`);

package/src/core/workflows/workflow-detector.js

@@ -22,9 +22,9 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
  * @returns {string} Framework root path
  */
 function getFrameworkRoot(projectPath) {
-  // Try npm-installed package first
+  // Try npm-installed package first (only if it has the workflow configs)
   const npmPath = join(projectPath, 'node_modules/@polymorphism-tech/morph-spec');
-  if (existsSync(npmPath)) {
+  if (existsSync(npmPath) && existsSync(join(npmPath, 'framework/workflows/configs'))) {
     return npmPath;
   }
 

package/stacks/blazor-azure/.claude/commands/morph-apply.md

@@ -0,0 +1,221 @@
+# Apply MORPH Feature Implementation - FASE 5
+
+Implemente a feature especificada seguindo as tasks definidas.
+
+## Uso
+
+```
+/morph-apply {feature-name}
+```
+
+## Pré-requisitos
+
+### CRÍTICO: Validar Fases Anteriores
+
+**SEMPRE verifique que fases anteriores foram concluídas:**
+
+```bash
+# Obter estado da feature
+npx morph-spec state get {feature-name}
+```
+
+**Validações obrigatórias:**
+
+1. **FASE 0 (Proposal):**
+   - [ ] Output `proposal` criado
+   - [ ] Agentes detectados e registrados
+
+2. **FASE 1 (Setup):**
+   - [ ] Phase passou por "setup"
+   - [ ] Contexto carregado
+
+3. **FASE 1.5 (UI/UX) - SE APLICÁVEL:**
+   - [ ] Se `uiux-designer` está nos activeAgents → outputs ui-* devem existir
+   - [ ] Se NÃO tem uiux-designer → pode pular
+
+4. **FASE 2 (Design):**
+   - [ ] Output `spec` criado
+   - [ ] Output `contracts` criado
+   - [ ] Output `decisions` criado
+
+5. **FASE 3 (Clarify):**
+   - [ ] Phase passou por "clarify"
+   - [ ] Spec atualizado com clarificações
+
+6. **FASE 4 (Tasks):**
+   - [ ] Output `tasks` criado
+   - [ ] `tasks.json` tem array de tasks
+   - [ ] `tasks.total` > 0 no state
+
+**Se QUALQUER validação falhar:**
+```
+❌ ERRO: Fase {X} não foi concluída!
+
+Para completar as fases de planejamento, execute:
+/morph-proposal {feature-name}
+(Resume automaticamente da fase atual: {current_phase})
+```
+
+**NÃO prossiga com implementação até todas as fases estarem completas!**
+
+### Arquivos Necessários
+
+- [ ] Feature existe em `.morph/project/outputs/{feature}/`
+- [ ] `spec.md` está aprovado
+- [ ] `tasks.json` tem tasks definidas
+- [ ] `contracts.cs` define as interfaces
+
+## Workflow
+
+1. **Carregue o contexto**:
+   - Leia `.morph/project/outputs/{feature}/spec.md`
+   - Leia `.morph/project/outputs/{feature}/tasks.json`
+   - Leia `.morph/project/outputs/{feature}/contracts.cs`
+   - Leia framework/standards/ e .morph/project/standards/ para padrões
+
+2. **Inicialize state tracking**:
+   ```bash
+   # Atualizar fase para implement
+   npx morph-spec state set {feature} phase implement
+   npx morph-spec state set {feature} status in_progress
+
+   # Definir total de tasks (baseado em tasks.json)
+   npx morph-spec state set {feature} tasks.total {N}
+   ```
+
+3. **Execute tasks em ordem**:
+   - Marque task como in progress: `npx morph-spec task start {feature} {task-id}`
+   - Implemente seguindo os padrões e contracts.cs
+   - Complete task: `npx morph-spec task done {feature} {task-id}`
+   - **Validators run automatically** on task-done. If validation fails:
+     - Read the error messages and fix violations
+     - Re-run `task done` — do NOT use `--skip-validation` unless user authorizes
+   - Framework auto-manages checkpoints (every 3 tasks, includes validation summary)
+
+4. **Phase advancement**:
+   ```bash
+   # Advance to next phase (validates → advances → shows next steps)
+   npx morph-spec phase advance {feature}
+   ```
+
+5. **Marcar outputs criados**:
+   Sempre que gerar um arquivo de output:
+   ```bash
+   npx morph-spec state mark-output {feature} spec
+   npx morph-spec state mark-output {feature} contracts
+   npx morph-spec state mark-output {feature} tasks
+   # etc.
+   ```
+
+6. **Ao finalizar**:
+   - Generate recap automatically: `npx morph-spec generate recap {feature}`
+   - Atualize state: `npx morph-spec state set {feature} status done`
+   - Marque recap: `npx morph-spec state mark-output {feature} recap`
+   - Liste arquivos criados/modificados
+   - Calcule custo real vs estimado
+
+## Padrões Obrigatórios
+
+Siga sempre (priorize project/standards/ se houver):
+- `framework/standards/coding.md` - Padrões base do MORPH
+- `.morph/project/standards/coding.md` - Padrões específicos do projeto
+- `.morph/project/standards/architecture.md` - Estrutura de projeto
+- `.morph/project/standards/azure.md` - Recursos e custos
+
+---
+
+## Checklist Pré-Deploy Azure
+
+**ANTES de fazer deploy para Azure, execute `/morph-preflight azure` ou verifique manualmente:**
+
+### Packages e Build
+
+- [ ] Packages sem conflitos de versão (`dotnet restore` sem warnings NU1605/NU1608)
+- [ ] `Azure.Identity` especificado explicitamente no `.csproj`
+- [ ] Build passa sem erros (`dotnet build`)
+
+### EF Core Migrations
+
+- [ ] Sem pending model changes (`dotnet ef migrations has-pending-model-changes`)
+- [ ] Migration criada para todas as mudanças de schema
+- [ ] Migration script revisado (`dotnet ef migrations script --idempotent`)
+
+### Blazor .NET 10 (se aplicável)
+
+- [ ] `.csproj` contém `<RequiresAspNetWebAssets>true</RequiresAspNetWebAssets>`
+- [ ] Static assets funcionando localmente
+
+### Container/Docker (se Container Apps)
+
+- [ ] Dockerfile válido e testado localmente
+- [ ] `docker build` funciona sem erros
+- [ ] Container roda localmente (`docker run`)
+
+### Infraestrutura Azure
+
+- [ ] Bicep sem erros de sintaxe (`az bicep build`)
+- [ ] Key Vault URI configurado em `appsettings.Production.json`
+- [ ] Connection strings em Key Vault (não hardcoded)
+- [ ] Managed Identity habilitada nos recursos
+
+### Segurança
+
+- [ ] Sem secrets em código ou `appsettings.json` (exceto Development)
+- [ ] HTTPS enforçado
+- [ ] CORS configurado corretamente
+
+### Comandos de Verificação
+
+```bash
+# 1. Package conflicts
+dotnet restore 2>&1 | grep -E "NU1605|NU1608"
+
+# 2. Pending migrations
+dotnet ef migrations has-pending-model-changes \
+  --project src/Infrastructure \
+  --startup-project src/Web
+
+# 3. Bicep validation
+az bicep build --file infra/main.bicep --stdout > /dev/null
+
+# 4. Docker build
+docker build -t myapp:test .
+
+# 5. Secret scan (basic)
+grep -rE "(Password=|Pwd=|Secret=)" appsettings*.json | grep -v Development
+```
+
+### Se QUALQUER item falhar
+
+```
+❌ BLOQUEADO: Não faça deploy até resolver!
+
+Use /morph-preflight azure para diagnóstico detalhado.
+```
+
+## Validações
+
+Antes de marcar task como completa:
+- [ ] Código compila
+- [ ] Segue padrões de nomenclatura
+- [ ] Testes unitários (se aplicável)
+- [ ] Sem hardcoded secrets
+
+## Output
+
+Ao final de cada task, mostre:
+1. Task completada
+2. Arquivos criados/modificados
+3. Próxima task
+4. Progresso geral (X/Y tasks) - usar `npx morph-spec state get {feature}`
+
+Ao final de cada checkpoint:
+```bash
+npx morph-spec state list
+```
+
+Isso mostra o progresso atualizado automaticamente.
+
+---
+
+**Feature:** $ARGUMENTS

package/stacks/blazor-azure/.claude/commands/morph-archive.md

@@ -0,0 +1,79 @@
+# Archive MORPH Feature
+
+Arquive uma feature concluída, movendo-a de `project/outputs/` para `project/archive/`.
+
+## Pré-requisitos
+
+Verifique antes de arquivar:
+- [ ] Feature existe em `.morph/project/outputs/{feature}/`
+- [ ] Todas as tasks estão completas
+- [ ] `recap.md` está preenchido
+- [ ] Código está em produção (ou staging)
+
+## Workflow
+
+1. **Valide a conclusão**:
+   - Leia `.morph/project/outputs/{feature}/tasks.json`
+   - Verifique que todas tasks estão completadas
+   - Confirme com o usuário se pode arquivar
+
+2. **Complete o recap**:
+   - Atualize `.morph/project/outputs/{feature}/recap.md`
+   - Preencha métricas finais
+   - Documente lições aprendidas
+
+3. **Extraia specs**:
+   - Se a feature define comportamento permanente
+   - Copie spec relevante para `.morph/project/specs/`
+   - Isso vira a "verdade atual" do sistema
+
+4. **Mova para archive**:
+   ```
+   .morph/project/outputs/{feature}/  →  .morph/project/archive/{feature}/
+   ```
+
+5. **Atualize métricas do projeto**:
+   - Incremente contador de features
+   - Atualize custo total
+   - Atualize tempo total
+
+## Output
+
+Apresente resumo do arquivamento:
+
+```
+╔════════════════════════════════════════════╗
+║         FEATURE ARCHIVED                   ║
+╠════════════════════════════════════════════╣
+║ Feature: {name}                            ║
+║ Completed: {date}                          ║
+╠════════════════════════════════════════════╣
+║ METRICS                                    ║
+╠════════════════════════════════════════════╣
+║ Tasks: {X}/{X} completed                   ║
+║ Time: {X}h (estimated: {Y}h)               ║
+║ Cost Impact: +${X}/month                   ║
+╠════════════════════════════════════════════╣
+║ FILES                                      ║
+╠════════════════════════════════════════════╣
+║ Created: {X} files                         ║
+║ Modified: {Y} files                        ║
+║ Tests: {Z} files ({W}% coverage)           ║
+╠════════════════════════════════════════════╣
+║ ARCHIVED TO                                ║
+╠════════════════════════════════════════════╣
+║ .morph/project/archive/{feature}/          ║
+╚════════════════════════════════════════════╝
+```
+
+## Specs Extraídas
+
+Se houver specs extraídas:
+```
+Specs extracted to .morph/project/specs/:
+- {domain}/spec.md - {description}
+```
+
+---
+
+**Feature to archive:** $ARGUMENTS