@polymorphism-tech/morph-spec 4.8.6 → 4.8.8

package/src/commands/templates/generate-contracts.js

@@ -0,0 +1,445 @@
+/**
+ * MORPH-SPEC Generate Contracts Command
+ *
+ * Reads schema-analysis.md and generates contracts.cs with REAL field names and types.
+ * Bridges the gap between schema analysis and contract template rendering (Problem 5 fix).
+ *
+ * Usage:
+ *   morph-spec generate contracts <feature>
+ *   morph-spec generate contracts <feature> --dry-run
+ *   morph-spec generate contracts <feature> --output <path>
+ */
+
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import chalk from 'chalk';
+import { logger } from '../../utils/logger.js';
+import { markOutput } from '../../core/state/state-manager.js';
+
+// ============================================================================
+// Type Mapping — SQL/TypeScript → C#
+// ============================================================================
+
+const TYPE_MAP = {
+  // String
+  'varchar': 'string', 'text': 'string', 'character varying': 'string',
+  'char': 'string', 'nvarchar': 'string', 'ntext': 'string', 'string': 'string',
+  'character': 'string', 'name': 'string', 'citext': 'string',
+  // UUID
+  'uuid': 'Guid', 'uniqueidentifier': 'Guid',
+  // Integer
+  'int': 'int', 'integer': 'int', 'int4': 'int', 'number': 'int',
+  'bigint': 'long', 'int8': 'long', 'smallint': 'short', 'int2': 'short',
+  'serial': 'int', 'bigserial': 'long', 'oid': 'int',
+  // Decimal
+  'decimal': 'decimal', 'numeric': 'decimal', 'money': 'decimal',
+  'float': 'double', 'double precision': 'double', 'real': 'float',
+  'float4': 'float', 'float8': 'double',
+  // Boolean
+  'boolean': 'bool', 'bool': 'bool', 'bit': 'bool',
+  // DateTime
+  'timestamp': 'DateTime', 'timestamp with time zone': 'DateTimeOffset',
+  'timestamp without time zone': 'DateTime', 'timestamptz': 'DateTimeOffset',
+  'datetime': 'DateTime', 'datetime2': 'DateTime', 'datetimeoffset': 'DateTimeOffset',
+  'date': 'DateOnly', 'time': 'TimeOnly', 'timetz': 'TimeOnly',
+  // JSON
+  'jsonb': 'JsonElement', 'json': 'JsonElement',
+  // Binary
+  'bytea': 'byte[]', 'binary': 'byte[]', 'varbinary': 'byte[]',
+};
+
+/**
+ * Map a raw SQL/TS type string to a C# type.
+ * Non-nullable value types get ? suffix when nullable is true.
+ */
+function toCSharpType(rawType, nullable) {
+  const lower = rawType.toLowerCase().trim();
+  const csType = TYPE_MAP[lower] ?? 'string';
+  const isReferenceType = csType === 'string' || csType === 'byte[]' || csType === 'JsonElement';
+  const suffix = nullable && !isReferenceType ? '?' : '';
+  return csType + suffix;
+}
+
+/**
+ * Convert snake_case / kebab-case / space-separated to PascalCase.
+ */
+function toPascalCase(str) {
+  return str
+    .split(/[_\s-]+/)
+    .map(w => (w ? w[0].toUpperCase() + w.slice(1).toLowerCase() : ''))
+    .join('');
+}
+
+/**
+ * Derive a C# entity class name from a table name.
+ * Strips a trailing plural 's' where safe (leads → Lead, users → User).
+ */
+function toEntityName(tableName) {
+  const pascal = toPascalCase(tableName);
+  // Simple singularization: strip trailing s unless double-s, -us, -ss pattern
+  if (pascal.endsWith('s') && !pascal.endsWith('ss') && !pascal.endsWith('us') && pascal.length > 3) {
+    return pascal.slice(0, -1);
+  }
+  return pascal;
+}
+
+// ============================================================================
+// Schema-Analysis Parser
+// ============================================================================
+
+/**
+ * Parse schema-analysis.md to extract table definitions with column metadata.
+ *
+ * Handles the standard MORPH-SPEC template output:
+ *   ### Table: <name>
+ *   **Columns:**
+ *   | Column Name | Type | Nullable | Default | Notes |
+ *   |------------|------|----------|---------|-------|
+ *   | id          | uuid | NO       | gen..() | PK    |
+ *
+ * @param {string} content - Raw file content of schema-analysis.md
+ * @returns {Array<{name: string, columns: Array<{name, type, nullable, notes}>}>}
+ */
+export function parseSchemaAnalysisMd(content) {
+  const tables = [];
+
+  // Locate all "### Table:" headings and slice between them
+  const headingRe = /^### Table:/gm;
+  const positions = [];
+  let m;
+  while ((m = headingRe.exec(content)) !== null) {
+    positions.push(m.index);
+  }
+  if (positions.length === 0) return tables;
+
+  const sections = positions.map((pos, i) => {
+    const end = positions[i + 1] ?? content.length;
+    return content.slice(pos, end);
+  });
+
+  for (const section of sections) {
+    const nameMatch = section.match(/^### Table:\s*(\S+)/);
+    if (!nameMatch) continue;
+    const tableName = nameMatch[1].replace(/[*`]/g, ''); // strip markdown decoration (preserve underscores)
+
+    // Find **Columns:** subsection
+    const colIdx = section.indexOf('**Columns:**');
+    if (colIdx === -1) continue;
+
+    const afterColumns = section.slice(colIdx + '**Columns:**'.length);
+    const columns = [];
+    let headerSeen = false;
+
+    for (const line of afterColumns.split('\n')) {
+      const trimmed = line.trim();
+
+      // Stop at next sub-section (**Relationships:**, **Indexes:**, etc.)
+      if (trimmed.startsWith('**') && trimmed.endsWith('**')) break;
+      if (!trimmed.startsWith('|')) continue;
+
+      // Split markdown table row into cells
+      const cells = trimmed.split('|').slice(1, -1).map(c => c.trim());
+      if (cells.length < 2) continue;
+
+      // Skip header row
+      if (!headerSeen && cells[0] === 'Column Name') {
+        headerSeen = true;
+        continue;
+      }
+
+      // Skip separator rows (---|---| etc.)
+      if (cells[0].match(/^-+:?$/) || cells[0].match(/^:?-+$/)) continue;
+
+      if (cells[0]) {
+        columns.push({
+          name: cells[0],
+          type: cells[1] || 'string',
+          nullable: (cells[2] || 'NO').toUpperCase() === 'YES',
+          default: cells[3] && cells[3] !== '-' ? cells[3] : null,
+          notes: cells[4] || '',
+        });
+      }
+    }
+
+    if (columns.length > 0) {
+      tables.push({ name: tableName, columns });
+    }
+  }
+
+  return tables;
+}
+
+// ============================================================================
+// Contract Generator
+// ============================================================================
+
+/**
+ * Determine whether a column is a primary key or auto-managed field
+ * (should be excluded from Create/Update requests).
+ */
+function isAutoManagedField(col) {
+  const name = col.name.toLowerCase();
+  const notes = col.notes.toLowerCase();
+  return (
+    notes.includes('pk') ||
+    name === 'id' ||
+    name === 'created_at' || name === 'createdat' ||
+    name === 'updated_at' || name === 'updatedat' ||
+    notes.includes('auto') || notes.includes('generated') || notes.includes('computed')
+  );
+}
+
+/**
+ * Generate C# contracts.cs content from parsed table definitions.
+ *
+ * Produces:
+ *   - One Dto record per table (all columns)
+ *   - One CreateRequest record per table (non-auto fields, required)
+ *   - One UpdateRequest record per table (non-auto fields, nullable/patch)
+ *   - Service interface for the primary table
+ *   - NotFoundException for the primary entity
+ *
+ * @param {Array} tables - Parsed table definitions
+ * @param {string} featureName - Feature name (used for namespace/class names)
+ * @param {string} namespace - C# namespace
+ * @returns {string} Generated C# source
+ */
+function generateContracts(tables, featureName, namespace) {
+  const entityName = toPascalCase(featureName);
+  const today = new Date().toISOString().split('T')[0];
+
+  const lines = [
+    `// ============================================================`,
+    `// CONTRACTS: ${entityName} — Generated from real schema-analysis.md`,
+    `// Generated by MORPH-SPEC generate contracts | Date: ${today}`,
+    `// Source: .morph/features/${featureName}/1-design/schema-analysis.md`,
+    `// Review: rename types, add validation attributes, adjust access modifiers.`,
+    `// ============================================================`,
+    ``,
+    `using System;`,
+    `using System.Text.Json;`,
+    `using System.Collections.Generic;`,
+    `using System.Threading;`,
+    `using System.Threading.Tasks;`,
+    ``,
+    `namespace ${namespace}.Application.Features.${entityName};`,
+    ``,
+  ];
+
+  for (const table of tables) {
+    const dtoPascal = toEntityName(table.name);
+    const userFields = table.columns.filter(c => !isAutoManagedField(c));
+
+    lines.push(`#region ${dtoPascal}`, ``);
+
+    // ── DTO ──────────────────────────────────────────────────────────────────
+    lines.push(`/// <summary>Read DTO — maps to the "${table.name}" table.</summary>`);
+    lines.push(`public record ${dtoPascal}Dto(`);
+    table.columns.forEach((col, i) => {
+      const csType = toCSharpType(col.type, col.nullable);
+      const propName = toPascalCase(col.name);
+      const comment = col.notes && col.notes !== '-' ? ` // ${table.name}.${col.name} (${col.type})` : '';
+      const comma = i < table.columns.length - 1 ? ',' : '';
+      lines.push(`    ${csType} ${propName}${comma}${comment}`);
+    });
+    lines.push(`);`, ``);
+
+    // ── Create Request ────────────────────────────────────────────────────────
+    lines.push(`/// <summary>Command to create a new ${dtoPascal}.</summary>`);
+    lines.push(`public record Create${dtoPascal}Request(`);
+    if (userFields.length > 0) {
+      userFields.forEach((col, i) => {
+        const csType = toCSharpType(col.type, false); // Required for create
+        const propName = toPascalCase(col.name);
+        const comma = i < userFields.length - 1 ? ',' : '';
+        lines.push(`    ${csType} ${propName}${comma}`);
+      });
+    } else {
+      lines.push(`    // TODO: Add required fields — all columns are auto-managed`);
+    }
+    lines.push(`);`, ``);
+
+    // ── Update Request ────────────────────────────────────────────────────────
+    lines.push(`/// <summary>Command to update an existing ${dtoPascal} (patch semantics).</summary>`);
+    lines.push(`public record Update${dtoPascal}Request(`);
+    if (userFields.length > 0) {
+      userFields.forEach((col, i) => {
+        const csType = toCSharpType(col.type, true); // All nullable for patch
+        const propName = toPascalCase(col.name);
+        const comma = i < userFields.length - 1 ? ',' : '';
+        lines.push(`    ${csType} ${propName}${comma}`);
+      });
+    } else {
+      lines.push(`    // TODO: Add updatable fields`);
+    }
+    lines.push(`);`, ``);
+    lines.push(`#endregion`, ``);
+  }
+
+  // ── Service Interface for primary entity ──────────────────────────────────
+  const primaryTable = tables[0];
+  const primaryEntity = primaryTable ? toEntityName(primaryTable.name) : entityName;
+
+  lines.push(
+    `#region Service Interface`,
+    ``,
+    `public interface I${entityName}Service`,
+    `{`,
+    `    Task<${primaryEntity}Dto?> GetByIdAsync(Guid id, CancellationToken ct = default);`,
+    `    Task<List<${primaryEntity}Dto>> GetAllAsync(CancellationToken ct = default);`,
+    `    Task<${primaryEntity}Dto> CreateAsync(Create${primaryEntity}Request request, CancellationToken ct = default);`,
+    `    Task UpdateAsync(Guid id, Update${primaryEntity}Request request, CancellationToken ct = default);`,
+    `    Task DeleteAsync(Guid id, CancellationToken ct = default);`,
+    `}`,
+    ``,
+    `#endregion`,
+    ``,
+  );
+
+  // ── Exception ─────────────────────────────────────────────────────────────
+  lines.push(
+    `#region Exceptions`,
+    ``,
+    `public class ${primaryEntity}NotFoundException(Guid id)`,
+    `    : Exception($"${primaryEntity} '{{id}}' not found.");`,
+    ``,
+    `#endregion`,
+  );
+
+  return lines.join('\n') + '\n';
+}
+
+// ============================================================================
+// Namespace Detection
+// ============================================================================
+
+/**
+ * Attempt to derive the C# namespace from project config or .csproj file.
+ */
+async function detectNamespace(projectPath) {
+  const configPath = join(projectPath, '.morph/config/config.json');
+  try {
+    const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+    if (config.project?.namespace) return config.project.namespace;
+    if (config.project?.name) {
+      return config.project.name
+        .split(/[\s\-_]+/)
+        .map(w => (w ? w[0].toUpperCase() + w.slice(1) : ''))
+        .join('');
+    }
+  } catch { /* ignore */ }
+
+  // Try to find a .csproj via git ls-files
+  try {
+    const { execSync } = await import('child_process');
+    const csprojList = execSync('git ls-files "*.csproj"', {
+      cwd: projectPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf-8',
+    }).trim().split('\n').filter(Boolean);
+    if (csprojList.length > 0) {
+      const name = csprojList[0].split('/').pop().replace('.csproj', '');
+      return name.replace(/\.|-/g, '');
+    }
+  } catch { /* not a git repo or no .csproj */ }
+
+  return 'YourProject';
+}
+
+// ============================================================================
+// CLI Entry Point
+// ============================================================================
+
+/**
+ * Main handler for: morph-spec generate contracts <feature>
+ *
+ * @param {string} featureName - Feature slug (e.g. "email-marketing")
+ * @param {Object} options
+ * @param {boolean} options.dryRun  - Print to stdout instead of writing
+ * @param {string}  options.output  - Override output path
+ */
+export async function generateContractsCommand(featureName, options = {}) {
+  logger.header(`Generate Contracts: ${featureName}`);
+  logger.blank();
+
+  const projectPath = options.projectPath || process.cwd();
+
+  // Locate schema-analysis.md
+  const schemaPath = join(projectPath, `.morph/features/${featureName}/1-design/schema-analysis.md`);
+  if (!existsSync(schemaPath)) {
+    logger.error(`schema-analysis.md not found at: ${schemaPath}`);
+    logger.dim('  Run the Design phase schema analysis first:');
+    logger.dim('    npx morph-spec phase advance ' + featureName);
+    logger.dim('    then execute /phase-codebase-analysis in Claude Code');
+    process.exit(1);
+  }
+
+  logger.dim(`Reading: ${schemaPath}`);
+  const content = readFileSync(schemaPath, 'utf-8');
+
+  // Parse tables
+  const tables = parseSchemaAnalysisMd(content);
+
+  if (tables.length === 0) {
+    logger.error('No tables found in schema-analysis.md');
+    logger.blank();
+    logger.dim('  Ensure the file uses the standard MORPH-SPEC format:');
+    logger.dim('    ### Table: your_table_name');
+    logger.dim('    **Columns:**');
+    logger.dim('    | Column Name | Type | Nullable | Default | Notes |');
+    logger.dim('    |------------|------|----------|---------|-------|');
+    logger.dim('    | id          | uuid | NO       | -       | PK    |');
+    process.exit(1);
+  }
+
+  logger.info(`Tables found: ${chalk.cyan(tables.map(t => t.name).join(', '))}`);
+  tables.forEach(t => {
+    const colSummary = t.columns
+      .slice(0, 4)
+      .map(c => `${c.name}:${c.type}`)
+      .join(', ');
+    const more = t.columns.length > 4 ? ` +${t.columns.length - 4} more` : '';
+    logger.dim(`  ${t.name}: ${colSummary}${more}`);
+  });
+  logger.blank();
+
+  // Detect namespace
+  const namespace = await detectNamespace(projectPath);
+  logger.dim(`Namespace: ${namespace}`);
+  logger.blank();
+
+  // Generate content
+  const contractsContent = generateContracts(tables, featureName, namespace);
+
+  // Output path
+  const outputPath = options.output
+    || join(projectPath, `.morph/features/${featureName}/1-design/contracts.cs`);
+
+  if (options.dryRun) {
+    logger.info(chalk.cyan('📋 DRY RUN — Preview (nothing written):'));
+    logger.blank();
+    console.log(contractsContent);
+    logger.dim(`Would be written to: ${outputPath}`);
+    return;
+  }
+
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, contractsContent, 'utf-8');
+
+  logger.success('✅ contracts.cs generated from real schema');
+  logger.dim(`  Output: ${chalk.cyan(outputPath)}`);
+  const totalCols = tables.reduce((n, t) => n + t.columns.length, 0);
+  logger.dim(`  ${tables.length} table(s) → ${totalCols} columns mapped`);
+  logger.blank();
+
+  // Mark output in state (non-blocking)
+  try {
+    markOutput(featureName, 'contracts');
+    logger.dim('  State: contracts output marked ✓');
+  } catch {
+    // Feature might not be in state yet — non-blocking
+  }
+
+  logger.blank();
+  logger.dim('Next step: review contracts.cs for type accuracy, then proceed with /phase-design');
+}

package/src/commands/templates/index.js

@@ -2,3 +2,4 @@
  * Template Commands
  */
 export { templateRenderCommand } from './template-render.js';
+export { generateContractsCommand, parseSchemaAnalysisMd } from './generate-contracts.js';

package/src/lib/validators/validation-runner.js

@@ -71,15 +71,25 @@ export async function runValidation(projectPath, featureName, options = {}) {
   validatorIds.push(...constraints.enabledValidators);
 
   if (validatorIds.length === 0) {
-    result.summary = 'No validators applicable for this feature';
+    // Distinguish: no agents vs. no validators mapped
+    const state = loadState(false);
+    const activeAgents = state?.features?.[featureName]?.activeAgents || [];
+    if (activeAgents.length === 0) {
+      result.summary = 'No validators ran — feature has no active agents';
+      console.log(chalk.gray('\n  ℹ️  No validators configured (no active agents in state.json)'));
+      console.log(chalk.gray('     Add agents: morph-spec state add-agent ' + featureName + ' <agent-id>'));
+    } else {
+      result.summary = `No validators mapped for active agents: ${activeAgents.join(', ')}`;
+      console.log(chalk.gray(`\n  ℹ️  Agents [${activeAgents.join(', ')}] have no validators in agents.json`));
+    }
+    result._skipReason = result.summary;
     return result;
   }
 
-  if (options.verbose) {
-    console.log(chalk.gray(`\n  Running validators: ${validatorIds.join(', ')}`));
-    if (constraints.enabledValidators.length > 0) {
-      console.log(chalk.gray(`  (+ ${constraints.enabledValidators.length} from decisions)`));
-    }
+  // Always show what's running (even non-verbose) — helps confirm validators are active
+  console.log(chalk.gray(`\n  Running ${validatorIds.length} validator(s): ${validatorIds.join(', ')}`));
+  if (constraints.enabledValidators.length > 0) {
+    console.log(chalk.gray(`  (+ ${constraints.enabledValidators.length} from decisions)`));
   }
 
   // Always run contract compliance if contracts.cs exists
@@ -234,7 +244,9 @@ async function runSingleValidator(validatorId, projectPath, featureName, options
  */
 export function formatValidationResults(result) {
   if (result.passed && result.warnings === 0) {
-    console.log(chalk.green('\n  ✅ All validations passed!\n'));
+    const ranCount = Object.keys(result.results || {}).length;
+    const countLabel = ranCount > 0 ? ` (${ranCount} validator${ranCount !== 1 ? 's' : ''})` : '';
+    console.log(chalk.green(`\n  ✅ All validations passed${countLabel}!\n`));
     return;
   }