@jaimevalasek/aioson 1.7.0 → 1.8.0

package/src/friction-scanner.js

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * friction-scanner — analyzes workflow error logs to detect recurring friction patterns.
+ *
+ * Reads .aioson/context/workflow.errors.jsonl and produces structured
+ * recommendations for codebase hardening.
+ */
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const { readFileSafe, fileExists } = require('./preflight-engine');
+
+const ERRORS_PATH = '.aioson/context/workflow.errors.jsonl';
+
+const PATTERNS = [
+  {
+    id: 'typescript_compile',
+    name: 'TypeScript compilation errors',
+    test: (err) => /tsc|typescript|type mismatch|cannot find module|unused import/i.test(err)
+  },
+  {
+    id: 'rust_compile',
+    name: 'Rust compilation errors',
+    test: (err) => /cargo check|rustc|sqlx|actix|tokio/i.test(err)
+  },
+  {
+    id: 'jsx_structure',
+    name: 'JSX / React structure errors',
+    test: (err) => /jsx|react|component|element type is invalid|nested|display-property/i.test(err)
+  },
+  {
+    id: 'test_mock_order',
+    name: 'Mock ordering / test helper issues',
+    test: (err) => /vi\.mock|vi\.fn|jest\.mock|mock ordering|hoisted|getByText/i.test(err)
+  },
+  {
+    id: 'ui_text_mismatch',
+    name: 'UI text mismatch in tests',
+    test: (err) => /confirmar|vincular|button label|tab name|ui text|assertion/i.test(err)
+  },
+  {
+    id: 'git_staging',
+    name: 'Git staging accidents',
+    test: (err) => /node_modules|build artifact|dev\.db|\.next|unwanted files staged/i.test(err)
+  },
+  {
+    id: 'path_misunderstanding',
+    name: 'Path / directory misinterpretation',
+    test: (err) => /wrong directory|path misunderstanding|bootstrap|\.aioson\/docs/i.test(err)
+  },
+  {
+    id: 'handoff_contract',
+    name: 'Handoff contract violations',
+    test: (err) => /handoff contract|missing artifact|gate .* not approved/i.test(err)
+  }
+];
+
+async function loadErrors(targetDir) {
+  const errorsPath = path.join(targetDir, ERRORS_PATH);
+  if (!(await fileExists(errorsPath))) return [];
+  const content = await readFileSafe(errorsPath);
+  if (!content) return [];
+  const lines = content.trim().split('\n').filter(Boolean);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      // ignore malformed lines
+    }
+  }
+  return entries;
+}
+
+function classifyError(entry) {
+  const text = `${entry.error || ''} ${entry.gateType || ''}`;
+  for (const pattern of PATTERNS) {
+    if (pattern.test(text)) {
+      return pattern.id;
+    }
+  }
+  return 'unknown';
+}
+
+async function scanFriction(targetDir) {
+  const entries = await loadErrors(targetDir);
+  const counts = {};
+  const byPattern = {};
+  const recent = entries.slice(-20);
+
+  for (const entry of entries) {
+    const pid = classifyError(entry);
+    counts[pid] = (counts[pid] || 0) + 1;
+    if (!byPattern[pid]) byPattern[pid] = [];
+    byPattern[pid].push(entry);
+  }
+
+  const sorted = Object.entries(counts)
+    .sort((a, b) => b[1] - a[1])
+    .map(([pid, count]) => {
+      const pattern = PATTERNS.find((p) => p.id === pid);
+      return {
+        id: pid,
+        name: pattern ? pattern.name : pid,
+        count,
+        examples: (byPattern[pid] || []).slice(-3).map((e) => e.error?.substring(0, 200) || '')
+      };
+    });
+
+  return {
+    total: entries.length,
+    recentCount: recent.length,
+    patterns: sorted
+  };
+}
+
+function buildRecommendations(analysis) {
+  const recs = [];
+  for (const p of analysis.patterns) {
+    switch (p.id) {
+      case 'typescript_compile':
+        recs.push({
+          pattern: p.name,
+          action: 'Enable strict type-checking hooks or add "tsc --noEmit" to pre-commit checks.',
+          autoFixable: false,
+          priority: p.count >= 3 ? 'high' : 'medium'
+        });
+        break;
+      case 'rust_compile':
+        recs.push({
+          pattern: p.name,
+          action: 'Add "cargo check" as a mandatory step in the dev agent prompt or CI pipeline.',
+          autoFixable: false,
+          priority: p.count >= 3 ? 'high' : 'medium'
+        });
+        break;
+      case 'jsx_structure':
+        recs.push({
+          pattern: p.name,
+          action: 'Add an ESLint plugin for JSX nesting rules (e.g., eslint-plugin-react).',
+          autoFixable: false,
+          priority: 'medium'
+        });
+        break;
+      case 'test_mock_order':
+        recs.push({
+          pattern: p.name,
+          action: 'Create a shared mock factory in tests/helpers/mocks.ts and update test conventions.',
+          autoFixable: true,
+          priority: p.count >= 2 ? 'high' : 'medium'
+        });
+        break;
+      case 'ui_text_mismatch':
+        recs.push({
+          pattern: p.name,
+          action: 'Enforce the test-briefing injection (already active) and add a rule to prefer getByRole.',
+          autoFixable: false,
+          priority: 'medium'
+        });
+        break;
+      case 'git_staging':
+        recs.push({
+          pattern: p.name,
+          action: 'Ensure .gitignore covers node_modules, dist, .next, *.db and install the pre-commit hook.',
+          autoFixable: true,
+          priority: 'high'
+        });
+        break;
+      case 'path_misunderstanding':
+        recs.push({
+          pattern: p.name,
+          action: 'Verify project-map.md exists and is loaded by implementation agents (already active).',
+          autoFixable: false,
+          priority: 'medium'
+        });
+        break;
+      case 'handoff_contract':
+        recs.push({
+          pattern: p.name,
+          action: 'Review agent prompts to ensure they set the correct gates and produce required artifacts.',
+          autoFixable: false,
+          priority: 'high'
+        });
+        break;
+      default:
+        recs.push({
+          pattern: p.name,
+          action: 'Investigate root cause manually and add a preventive rule.',
+          autoFixable: false,
+          priority: 'low'
+        });
+    }
+  }
+  return recs;
+}
+
+module.exports = {
+  scanFriction,
+  buildRecommendations,
+  PATTERNS
+};

package/src/genome-schema.js

@@ -6,6 +6,7 @@ const {
   GENOME_FORMATS,
   GENOME_CONFIDENCE_LEVELS,
   GENOME_TYPES,
+  GENOME_RELATION_TYPES,
   countGenomeSections,
   normalizeGenome,
   normalizeGenomeMeta
@@ -79,6 +80,18 @@ function validatePersonaV3Requirements(normalized, sections, errors) {
       errors.push(`sections.${key} must contain at least one entry for genome-v3 persona profiles`);
     }
   }
+
+  // track 4.0 — optional, validate only if present
+  if (normalized.hexacoH && !GENOME_CONFIDENCE_LEVELS.includes(normalized.hexacoH)) {
+    errors.push(`hexaco_h must be one of: ${GENOME_CONFIDENCE_LEVELS.join(', ')}`);
+  }
+  if (Array.isArray(normalized.relations)) {
+    for (const rel of normalized.relations) {
+      if (rel.type && !GENOME_RELATION_TYPES.includes(rel.type)) {
+        errors.push(`relations[].type must be one of: ${GENOME_RELATION_TYPES.join(', ')}`);
+      }
+    }
+  }
 }
 
 function validateGenomeObject(input) {
@@ -155,6 +168,7 @@ function validateGenomeMeta(input) {
         cognitiveProfile: Array(meta.counts.cognitiveProfile).fill('x'),
         communicationStyle: Array(meta.counts.communicationStyle).fill('x'),
         biases: Array(meta.counts.biases).fill('x'),
+        traitInteractions: Array(meta.counts.traitInteractions || 0).fill('x'),
         conflictResolution: Array(meta.counts.conflictResolution).fill('x'),
         evidence: Array(meta.counts.evidence).fill('x'),
         applicationNotes: Array(meta.counts.applicationNotes).fill('x')
@@ -168,6 +182,14 @@ function validateGenomeMeta(input) {
   }
   if (!meta.createdAt) errors.push('createdAt is required');
   if (!meta.updatedAt) errors.push('updatedAt is required');
+  if (hasOwn(input, 'dependencies') && input.dependencies !== null && typeof input.dependencies === 'object') {
+    if ('skills' in input.dependencies && !Array.isArray(input.dependencies.skills)) {
+      errors.push('dependencies.skills must be an array of strings');
+    }
+    if ('genomes' in input.dependencies && !Array.isArray(input.dependencies.genomes)) {
+      errors.push('dependencies.genomes must be an array of strings');
+    }
+  }
   validatePersonaV3Requirements(
     {
       version: meta.version,
@@ -183,7 +205,8 @@ function validateGenomeMeta(input) {
     {
       cognitiveProfile: Array(meta.counts.cognitiveProfile).fill('x'),
       communicationStyle: Array(meta.counts.communicationStyle).fill('x'),
-      biases: Array(meta.counts.biases).fill('x')
+      biases: Array(meta.counts.biases).fill('x'),
+      traitInteractions: Array(meta.counts.traitInteractions || 0).fill('x')
     },
     errors
   );

package/src/genomes.js

@@ -22,6 +22,7 @@ const GENOME_V3_SECTION_KEYS = [
   'cognitiveProfile',
   'communicationStyle',
   'biases',
+  'traitInteractions',
   'conflictResolution'
 ];
 const GENOME_SECTION_KEYS = [...GENOME_CANONICAL_SECTION_KEYS, ...GENOME_V3_SECTION_KEYS];
@@ -102,6 +103,21 @@ function normalizeStringArray(value) {
     .filter(Boolean);
 }
 
+const GENOME_RELATION_TYPES = ['complementa', 'contradiz', 'depende-de', 'sobrepos'];
+
+function normalizeRelations(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((entry) => {
+      if (!entry || typeof entry !== 'object') return null;
+      const genome = normalizeText(entry.genome || entry.slug);
+      const type = normalizeText(entry.type);
+      if (!genome) return null;
+      return { genome, type };
+    })
+    .filter(Boolean);
+}
+
 function normalizeGenomeVersion(value, fallback = 2) {
   const parsed = Number.parseInt(String(value || ''), 10);
   if (!Number.isFinite(parsed)) return fallback;
@@ -193,6 +209,9 @@ function createEmptyGenome() {
     enneagram: '',
     bigFive: '',
     mbti: '',
+    hexacoH: '',
+    anchorPrompt: '',
+    relations: [],
     confidence: '',
     profilerReport: '',
     hybridMode: '',
@@ -210,6 +229,7 @@ function createEmptyGenome() {
       cognitiveProfile: [],
       communicationStyle: [],
       biases: [],
+      traitInteractions: [],
       conflictResolution: [],
       evidence: [],
       applicationNotes: []
@@ -289,6 +309,9 @@ function normalizeGenome(input = {}) {
     enneagram: normalizeText(merged.enneagram),
     bigFive: normalizeText(merged.bigFive || merged.big_five),
     mbti: normalizeText(merged.mbti),
+    hexacoH: normalizeOptionalEnum(merged.hexacoH || merged.hexaco_h, GENOME_CONFIDENCE_LEVELS),
+    anchorPrompt: normalizeText(merged.anchorPrompt || merged.anchor_prompt),
+    relations: normalizeRelations(merged.relations),
     confidence: normalizeOptionalEnum(merged.confidence, GENOME_CONFIDENCE_LEVELS),
     profilerReport: normalizeText(merged.profilerReport || merged.profiler_report),
     hybridMode: normalizeOptionalEnum(
@@ -315,6 +338,7 @@ function countGenomeSections(input = {}) {
     cognitiveProfile: genome.sections.cognitiveProfile.length,
     communicationStyle: genome.sections.communicationStyle.length,
     biases: genome.sections.biases.length,
+    traitInteractions: genome.sections.traitInteractions.length,
     conflictResolution: genome.sections.conflictResolution.length,
     evidence: genome.sections.evidence.length,
     applicationNotes: genome.sections.applicationNotes.length
@@ -334,6 +358,7 @@ function normalizeCounts(value = {}) {
     cognitiveProfile: normalizeInteger(value.cognitiveProfile, 0),
     communicationStyle: normalizeInteger(value.communicationStyle, 0),
     biases: normalizeInteger(value.biases, 0),
+    traitInteractions: normalizeInteger(value.traitInteractions, 0),
     conflictResolution: normalizeInteger(value.conflictResolution, 0),
     evidence: normalizeInteger(value.evidence, 0),
     applicationNotes: normalizeInteger(value.applicationNotes, 0)
@@ -390,6 +415,9 @@ function normalizeGenomeMeta(input = {}) {
     enneagram: normalizeText(input.enneagram || (genome && genome.enneagram)),
     bigFive: normalizeText(input.bigFive || input.big_five || (genome && genome.bigFive)),
     mbti: normalizeText(input.mbti || (genome && genome.mbti)),
+    hexacoH: normalizeOptionalEnum(input.hexacoH || input.hexaco_h || (genome && genome.hexacoH), GENOME_CONFIDENCE_LEVELS),
+    anchorPrompt: normalizeText(input.anchorPrompt || input.anchor_prompt || (genome && genome.anchorPrompt)),
+    relations: normalizeRelations(input.relations || (genome && genome.relations)),
     confidence: normalizeOptionalEnum(input.confidence || (genome && genome.confidence), GENOME_CONFIDENCE_LEVELS),
     profilerReport: normalizeText(input.profilerReport || input.profiler_report || (genome && genome.profilerReport)),
     hybridMode: normalizeOptionalEnum(
@@ -416,6 +444,10 @@ function normalizeGenomeMeta(input = {}) {
       squads: normalizeStringArray(input.bindings && input.bindings.squads),
       agents: normalizeStringArray(input.bindings && input.bindings.agents)
     },
+    dependencies: {
+      skills: normalizeStringArray(input.dependencies && input.dependencies.skills),
+      genomes: normalizeStringArray(input.dependencies && input.dependencies.genomes)
+    },
     createdAt,
     updatedAt
   };
@@ -455,6 +487,7 @@ module.exports = {
   GENOME_FORMATS,
   GENOME_CONFIDENCE_LEVELS,
   GENOME_HYBRID_MODES,
+  GENOME_RELATION_TYPES,
   GENOME_SECTION_KEYS,
   GENOME_CANONICAL_SECTION_KEYS,
   GENOME_V3_SECTION_KEYS,