@polymorphism-tech/morph-spec 3.2.0 → 4.3.0

package/src/lib/{troubleshoot-index.js → troubleshooting/troubleshoot-index.js}

@@ -1,144 +1,144 @@
-/**
- * Troubleshoot Index Search
- * Searches the troubleshooting-index.json for matching problems
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-/**
- * Load the troubleshooting index
- * @returns {Object} The index object or null if not found
- */
-export function loadIndex() {
-  const indexPath = join(__dirname, '../../framework/index/troubleshooting-index.json');
-
-  if (!existsSync(indexPath)) {
-    return null;
-  }
-
-  try {
-    const content = readFileSync(indexPath, 'utf-8');
-    return JSON.parse(content);
-  } catch (error) {
-    console.error('Error loading troubleshooting index:', error.message);
-    return null;
-  }
-}
-
-/**
- * Calculate relevance score for a problem based on keywords
- * @param {Object} problem - The problem object from index
- * @param {string[]} searchTerms - Search terms from user
- * @returns {number} Relevance score (higher is better)
- */
-function calculateScore(problem, searchTerms) {
-  let score = 0;
-  const searchLower = searchTerms.map(t => t.toLowerCase());
-
-  // Check keywords
-  for (const keyword of problem.keywords) {
-    const keywordLower = keyword.toLowerCase();
-    for (const term of searchLower) {
-      if (keywordLower.includes(term) || term.includes(keywordLower)) {
-        score += 10;
-      }
-    }
-  }
-
-  // Check title
-  const titleLower = problem.title.toLowerCase();
-  for (const term of searchLower) {
-    if (titleLower.includes(term)) {
-      score += 5;
-    }
-  }
-
-  // Check error pattern (regex match on search string)
-  if (problem.errorPattern) {
-    try {
-      const regex = new RegExp(problem.errorPattern, 'i');
-      const searchString = searchTerms.join(' ');
-      if (regex.test(searchString)) {
-        score += 20; // High score for error pattern match
-      }
-    } catch (e) {
-      // Invalid regex, skip
-    }
-  }
-
-  // Boost critical severity
-  if (problem.severity === 'critical') {
-    score *= 1.2;
-  }
-
-  return score;
-}
-
-/**
- * Search the index for problems matching the keywords
- * @param {string[]} keywords - Search keywords
- * @param {Object} options - Search options
- * @param {string} options.category - Filter by category
- * @returns {Object[]} Array of matching problems with scores
- */
-export function searchIndex(keywords, options = {}) {
-  const index = loadIndex();
-
-  if (!index || !index.problems) {
-    return [];
-  }
-
-  let problems = index.problems;
-
-  // Filter by category if specified
-  if (options.category) {
-    problems = problems.filter(p => p.category === options.category);
-  }
-
-  // Score and filter problems
-  const results = problems
-    .map(problem => ({
-      ...problem,
-      score: calculateScore(problem, keywords)
-    }))
-    .filter(p => p.score > 0)
-    .sort((a, b) => b.score - a.score);
-
-  return results;
-}
-
-/**
- * Get all categories from the index
- * @returns {Object} Categories object
- */
-export function getCategories() {
-  const index = loadIndex();
-  return index?.categories || {};
-}
-
-/**
- * Get a specific problem by ID
- * @param {string} id - Problem ID
- * @returns {Object|null} Problem object or null
- */
-export function getProblemById(id) {
-  const index = loadIndex();
-
-  if (!index || !index.problems) {
-    return null;
-  }
-
-  return index.problems.find(p => p.id === id) || null;
-}
-
-export default {
-  loadIndex,
-  searchIndex,
-  getCategories,
-  getProblemById
-};
+/**
+ * Troubleshoot Index Search
+ * Searches the troubleshooting-index.json for matching problems
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Load the troubleshooting index
+ * @returns {Object} The index object or null if not found
+ */
+export function loadIndex() {
+  const indexPath = join(__dirname, '../../framework/index/troubleshooting-index.json');
+
+  if (!existsSync(indexPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(indexPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error('Error loading troubleshooting index:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Calculate relevance score for a problem based on keywords
+ * @param {Object} problem - The problem object from index
+ * @param {string[]} searchTerms - Search terms from user
+ * @returns {number} Relevance score (higher is better)
+ */
+function calculateScore(problem, searchTerms) {
+  let score = 0;
+  const searchLower = searchTerms.map(t => t.toLowerCase());
+
+  // Check keywords
+  for (const keyword of problem.keywords) {
+    const keywordLower = keyword.toLowerCase();
+    for (const term of searchLower) {
+      if (keywordLower.includes(term) || term.includes(keywordLower)) {
+        score += 10;
+      }
+    }
+  }
+
+  // Check title
+  const titleLower = problem.title.toLowerCase();
+  for (const term of searchLower) {
+    if (titleLower.includes(term)) {
+      score += 5;
+    }
+  }
+
+  // Check error pattern (regex match on search string)
+  if (problem.errorPattern) {
+    try {
+      const regex = new RegExp(problem.errorPattern, 'i');
+      const searchString = searchTerms.join(' ');
+      if (regex.test(searchString)) {
+        score += 20; // High score for error pattern match
+      }
+    } catch (e) {
+      // Invalid regex, skip
+    }
+  }
+
+  // Boost critical severity
+  if (problem.severity === 'critical') {
+    score *= 1.2;
+  }
+
+  return score;
+}
+
+/**
+ * Search the index for problems matching the keywords
+ * @param {string[]} keywords - Search keywords
+ * @param {Object} options - Search options
+ * @param {string} options.category - Filter by category
+ * @returns {Object[]} Array of matching problems with scores
+ */
+export function searchIndex(keywords, options = {}) {
+  const index = loadIndex();
+
+  if (!index || !index.problems) {
+    return [];
+  }
+
+  let problems = index.problems;
+
+  // Filter by category if specified
+  if (options.category) {
+    problems = problems.filter(p => p.category === options.category);
+  }
+
+  // Score and filter problems
+  const results = problems
+    .map(problem => ({
+      ...problem,
+      score: calculateScore(problem, keywords)
+    }))
+    .filter(p => p.score > 0)
+    .sort((a, b) => b.score - a.score);
+
+  return results;
+}
+
+/**
+ * Get all categories from the index
+ * @returns {Object} Categories object
+ */
+export function getCategories() {
+  const index = loadIndex();
+  return index?.categories || {};
+}
+
+/**
+ * Get a specific problem by ID
+ * @param {string} id - Problem ID
+ * @returns {Object|null} Problem object or null
+ */
+export function getProblemById(id) {
+  const index = loadIndex();
+
+  if (!index || !index.problems) {
+    return null;
+  }
+
+  return index.problems.find(p => p.id === id) || null;
+}
+
+export default {
+  loadIndex,
+  searchIndex,
+  getCategories,
+  getProblemById
+};

package/src/lib/trust/trust-manager.js

@@ -0,0 +1,269 @@
+/**
+ * Trust Manager — Track-record and auto-approval logic
+ *
+ * Computes trust level from checkpoint pass rate history.
+ * Enables auto-approval gates for features with proven track records.
+ *
+ * Trust levels:
+ *   low     < 80% pass rate
+ *   medium  80–90%
+ *   high    90–95%
+ *   maximum > 95%
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+// Default trust config (matches llm-interaction.json thresholds)
+const TRUST_THRESHOLDS = {
+  low: 0,
+  medium: 0.80,
+  high: 0.90,
+  maximum: 0.95
+};
+
+// Gates that can be auto-approved by trust level
+const AUTO_APPROVE_GATES = {
+  medium: ['design'],
+  high: ['design', 'tasks'],
+  maximum: ['design', 'tasks', 'proposal']
+};
+
+/**
+ * Load state.json
+ * @returns {Object} State
+ */
+function loadState() {
+  const statePath = join(process.cwd(), '.morph/state.json');
+  if (!existsSync(statePath)) return { features: {} };
+  try {
+    return JSON.parse(readFileSync(statePath, 'utf8'));
+  } catch {
+    return { features: {} };
+  }
+}
+
+/**
+ * Save state.json
+ * @param {Object} state
+ */
+function saveState(state) {
+  const statePath = join(process.cwd(), '.morph/state.json');
+  writeFileSync(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+
+/**
+ * Calculate trust level from checkpoint history
+ * @param {Array} checkpoints - Array of { passed: boolean, ... }
+ * @returns {{ level: string, passRate: number, total: number, passed: number }}
+ */
+export function calculateTrust(checkpoints = []) {
+  if (checkpoints.length === 0) {
+    return { level: 'low', passRate: 0, total: 0, passed: 0 };
+  }
+
+  const total = checkpoints.length;
+  const passed = checkpoints.filter(c => c.passed).length;
+  const passRate = passed / total;
+
+  let level = 'low';
+  if (passRate >= TRUST_THRESHOLDS.maximum) level = 'maximum';
+  else if (passRate >= TRUST_THRESHOLDS.high) level = 'high';
+  else if (passRate >= TRUST_THRESHOLDS.medium) level = 'medium';
+
+  return { level, passRate, total, passed };
+}
+
+/**
+ * Get current trust config for a feature
+ * @param {string} featureName
+ * @returns {{ level: string, passRate: number, autoApprove: string[], override?: string }}
+ */
+export function getTrust(featureName) {
+  const state = loadState();
+  const feature = state.features?.[featureName];
+
+  if (!feature) {
+    return { level: 'low', passRate: 0, autoApprove: [], source: 'default' };
+  }
+
+  // Check for manual override first
+  if (feature.trustConfig?.override) {
+    return {
+      level: feature.trustConfig.override.level,
+      passRate: feature.trustConfig.passRate || 0,
+      autoApprove: AUTO_APPROVE_GATES[feature.trustConfig.override.level] || [],
+      source: 'manual',
+      overrideReason: feature.trustConfig.override.reason,
+      overrideAt: feature.trustConfig.override.setAt
+    };
+  }
+
+  // Calculate from checkpoint history
+  const checkpoints = feature.checkpoints || [];
+  const { level, passRate, total, passed } = calculateTrust(checkpoints);
+
+  return {
+    level,
+    passRate,
+    total,
+    passed,
+    autoApprove: AUTO_APPROVE_GATES[level] || [],
+    source: 'calculated'
+  };
+}
+
+/**
+ * Manually set trust level with reason
+ * @param {string} featureName
+ * @param {string} level - 'low' | 'medium' | 'high' | 'maximum'
+ * @param {string} reason
+ */
+export function setTrust(featureName, level, reason) {
+  const validLevels = ['low', 'medium', 'high', 'maximum'];
+  if (!validLevels.includes(level)) {
+    throw new Error(`Invalid trust level: ${level}. Valid: ${validLevels.join(', ')}`);
+  }
+
+  const state = loadState();
+  if (!state.features[featureName]) {
+    throw new Error(`Feature not found: ${featureName}`);
+  }
+
+  if (!state.features[featureName].trustConfig) {
+    state.features[featureName].trustConfig = {};
+  }
+
+  state.features[featureName].trustConfig.override = {
+    level,
+    reason,
+    setAt: new Date().toISOString(),
+    setBy: 'manual'
+  };
+
+  saveState(state);
+
+  return {
+    feature: featureName,
+    level,
+    autoApprove: AUTO_APPROVE_GATES[level] || [],
+    reason
+  };
+}
+
+/**
+ * Clear manual trust override (revert to calculated)
+ * @param {string} featureName
+ */
+export function clearTrustOverride(featureName) {
+  const state = loadState();
+  if (state.features[featureName]?.trustConfig?.override) {
+    delete state.features[featureName].trustConfig.override;
+    saveState(state);
+  }
+}
+
+/**
+ * Check if a gate should be auto-approved based on trust level
+ * @param {string} featureName
+ * @param {string} gate - 'design' | 'tasks' | 'proposal'
+ * @returns {{ autoApprove: boolean, level: string, reason: string }}
+ */
+export function shouldAutoApprove(featureName, gate) {
+  const trust = getTrust(featureName);
+
+  if (!trust.autoApprove.includes(gate)) {
+    return {
+      autoApprove: false,
+      level: trust.level,
+      reason: `Trust level "${trust.level}" does not auto-approve "${gate}" gate (need: ${getMinLevelForGate(gate)})`
+    };
+  }
+
+  return {
+    autoApprove: true,
+    level: trust.level,
+    reason: `Auto-approved: ${trust.level} trust (${Math.round(trust.passRate * 100)}% pass rate, ${trust.total} checkpoints)`,
+    passRate: trust.passRate,
+    checkpointsTotal: trust.total
+  };
+}
+
+/**
+ * Get minimum trust level required for a gate
+ * @param {string} gate
+ * @returns {string}
+ */
+function getMinLevelForGate(gate) {
+  for (const [level, gates] of Object.entries(AUTO_APPROVE_GATES)) {
+    if (gates.includes(gate)) return level;
+  }
+  return 'maximum';
+}
+
+/**
+ * Get trust history for all features
+ * @returns {Array} Feature trust summaries
+ */
+export function getTrustHistory() {
+  const state = loadState();
+  const features = state.features || {};
+
+  return Object.entries(features).map(([name, feature]) => {
+    const trust = getTrust(name);
+    return {
+      feature: name,
+      level: trust.level,
+      passRate: trust.passRate,
+      checkpointsTotal: trust.total || 0,
+      checkpointsPassed: trust.passed || 0,
+      autoApprove: trust.autoApprove,
+      source: trust.source,
+      phase: feature.phase,
+      status: feature.status
+    };
+  });
+}
+
+/**
+ * Auto-calculate and update trust in state
+ * @param {string} featureName
+ * @returns {Object} Updated trust config
+ */
+export function autoCalculateTrust(featureName) {
+  const state = loadState();
+  const feature = state.features?.[featureName];
+
+  if (!feature) {
+    throw new Error(`Feature not found: ${featureName}`);
+  }
+
+  const checkpoints = feature.checkpoints || [];
+  const { level, passRate, total, passed } = calculateTrust(checkpoints);
+
+  if (!state.features[featureName].trustConfig) {
+    state.features[featureName].trustConfig = {};
+  }
+
+  state.features[featureName].trustConfig = {
+    ...state.features[featureName].trustConfig,
+    level,
+    passRate,
+    checkpointsTotal: total,
+    checkpointsPassed: passed,
+    lastCalculated: new Date().toISOString()
+  };
+
+  saveState(state);
+
+  return {
+    feature: featureName,
+    level,
+    passRate,
+    total,
+    passed,
+    autoApprove: AUTO_APPROVE_GATES[level] || []
+  };
+}
+
+export { TRUST_THRESHOLDS, AUTO_APPROVE_GATES };

package/src/lib/validators/{architecture-validator.js → architecture/architecture-validator.js}

@@ -4,7 +4,7 @@
  * Validates architectural patterns and detects anti-patterns in Blazor apps.
  * Prevents common DI mistakes, lifecycle issues, and coupling problems.
  *
- * Source: framework/standards/blazor-pitfalls.md
+ * Source: framework/standards/frontend/blazor/pitfalls.md
  * MORPH-SPEC 3.0 - Sprint 4
  */
 
@@ -21,7 +21,7 @@ const VALIDATION_RULES = {
     pattern: /\[Inject\].*I\w+(Command|Query|Handler)/,
     level: 'error',
     message: 'Blazor component injecting Application layer directly (use HttpClient pattern)',
-    reference: 'framework/standards/blazor-pitfalls.md#di-pattern',
+    reference: 'framework/standards/frontend/blazor/pitfalls.md#di-pattern',
     solution: 'Replace with HttpClient and call API endpoint'
   },
 
@@ -29,7 +29,7 @@ const VALIDATION_RULES = {
     pattern: /\[Inject\].*DbContext/,
     level: 'error',
     message: 'Blazor component injecting DbContext directly (use HttpClient → API → Handler)',
-    reference: 'framework/standards/blazor-pitfalls.md#di-pattern',
+    reference: 'framework/standards/frontend/blazor/pitfalls.md#di-pattern',
     solution: 'Use HttpClient to call API, which then uses handler/repository'
   },
 
@@ -37,7 +37,7 @@ const VALIDATION_RULES = {
     pattern: /\[Inject\].*I\w+Repository/,
     level: 'warning',
     message: 'Blazor component injecting Repository directly (prefer HttpClient → API pattern)',
-    reference: 'framework/standards/blazor-pitfalls.md#di-pattern',
+    reference: 'framework/standards/frontend/blazor/pitfalls.md#di-pattern',
     solution: 'Consider using HttpClient for better separation'
   },
 
@@ -46,7 +46,7 @@ const VALIDATION_RULES = {
     pattern: /OnInitialized(?:Async)?\(\)[\s\S]*?JSRuntime/,
     level: 'error',
     message: 'JSRuntime called in OnInitialized (must use OnAfterRenderAsync)',
-    reference: 'framework/standards/blazor-lifecycle.md#jsruntime',
+    reference: 'framework/standards/frontend/blazor/lifecycle.md#jsruntime',
     solution: 'Move JSRuntime calls to OnAfterRenderAsync with firstRender guard'
   },
 
@@ -54,7 +54,7 @@ const VALIDATION_RULES = {
     pattern: /async\s+void\s+On\w+/,
     level: 'warning',
     message: 'Async void event handler (prefer async Task for error handling)',
-    reference: 'framework/standards/blazor-lifecycle.md#async',
+    reference: 'framework/standards/frontend/blazor/lifecycle.md#async',
     solution: 'Change return type to async Task'
   },
 
@@ -99,7 +99,7 @@ const VALIDATION_RULES = {
     pattern: /IFormFile.*Blazor/,
     level: 'error',
     message: 'Using IFormFile in Blazor (use IBrowserFile)',
-    reference: 'framework/standards/blazor-pitfalls.md#file-upload',
+    reference: 'framework/standards/frontend/blazor/pitfalls.md#file-upload',
     solution: 'Use IBrowserFile in Blazor components, convert to IFormFile in API'
   },
 
@@ -108,7 +108,7 @@ const VALIDATION_RULES = {
     pattern: /private\s+(?:static\s+)?List<.*>.*=\s*new/,
     level: 'warning',
     message: 'In-memory state in component (consider using proper state management)',
-    reference: 'framework/standards/blazor-pitfalls.md#state',
+    reference: 'framework/standards/frontend/blazor/pitfalls.md#state',
     solution: 'Use Fluxor, or move state to API/database'
   }
 };

package/src/lib/validators/architecture/index.js

@@ -0,0 +1,7 @@
+/**
+ * Architecture Validators
+ *
+ * Architecture pattern validation (DI, CQRS, etc.)
+ */
+
+export * from './architecture-validator.js';