@jaimevalasek/aioson 1.3.0

package/src/genome-format.js

@@ -0,0 +1,442 @@
+'use strict';
+
+const {
+  GENOME_SECTION_KEYS,
+  countGenomeSections,
+  normalizeGenome
+} = require('./genomes');
+
+const SECTION_ORDER = [
+  ['knowledge', 'O que saber'],
+  ['philosophies', 'Filosofias'],
+  ['mentalModels', 'Modelos mentais'],
+  ['heuristics', 'Heurísticas'],
+  ['frameworks', 'Frameworks'],
+  ['methodologies', 'Metodologias'],
+  ['mentes', 'Mentes'],
+  ['skills', 'Skills'],
+  ['cognitiveProfile', 'Perfil Cognitivo'],
+  ['communicationStyle', 'Estilo de Comunicação'],
+  ['biases', 'Vieses e Pontos Cegos'],
+  ['conflictResolution', 'Conflict Resolution'],
+  ['evidence', 'Evidence'],
+  ['applicationNotes', 'Application notes']
+];
+
+const SECTION_ALIASES = new Map([
+  ['o que saber', 'knowledge'],
+  ['what to know', 'knowledge'],
+  ['filosofias', 'philosophies'],
+  ['philosophies', 'philosophies'],
+  ['modelos mentais', 'mentalModels'],
+  ['mental models', 'mentalModels'],
+  ['heuristicas', 'heuristics'],
+  ['heuristics', 'heuristics'],
+  ['frameworks', 'frameworks'],
+  ['metodologias', 'methodologies'],
+  ['methodologies', 'methodologies'],
+  ['mentes', 'mentes'],
+  ['minds', 'mentes'],
+  ['skills', 'skills'],
+  ['habilidades', 'skills'],
+  ['perfil cognitivo', 'cognitiveProfile'],
+  ['cognitive profile', 'cognitiveProfile'],
+  ['estilo de comunicacao', 'communicationStyle'],
+  ['communication style', 'communicationStyle'],
+  ['vieses e pontos cegos', 'biases'],
+  ['biases and blind spots', 'biases'],
+  ['conflict resolution', 'conflictResolution'],
+  ['resolucao de conflito', 'conflictResolution'],
+  ['evidence', 'evidence'],
+  ['evidencias', 'evidence'],
+  ['application notes', 'applicationNotes'],
+  ['notas de aplicacao', 'applicationNotes']
+]);
+
+function stripBOM(value) {
+  return String(value || '').replace(/^\uFEFF/, '');
+}
+
+function normalizeHeading(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '');
+}
+
+function parseScalar(rawValue) {
+  const value = String(rawValue || '').trim();
+  if (!value) return '';
+  if (
+    (value.startsWith('[') && value.endsWith(']')) ||
+    (value.startsWith('{') && value.endsWith('}'))
+  ) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  if (
+    (value.startsWith('"') && value.endsWith('"')) ||
+    (value.startsWith("'") && value.endsWith("'"))
+  ) {
+    return value.slice(1, -1);
+  }
+  if (/^-?\d+$/.test(value)) return Number.parseInt(value, 10);
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return value;
+}
+
+function extractFrontmatter(markdown) {
+  const text = stripBOM(markdown);
+  if (!text.startsWith('---\n') && !text.startsWith('---\r\n')) {
+    return {
+      attributes: {},
+      body: text,
+      hasFrontmatter: false
+    };
+  }
+
+  const lines = text.split(/\r?\n/);
+  let closingIndex = -1;
+  for (let index = 1; index < lines.length; index += 1) {
+    if (lines[index].trim() === '---') {
+      closingIndex = index;
+      break;
+    }
+  }
+
+  if (closingIndex === -1) {
+    throw new Error('Invalid genome markdown: unclosed frontmatter block.');
+  }
+
+  const attributes = {};
+  for (let index = 1; index < closingIndex; index += 1) {
+    const line = lines[index].trim();
+    if (!line || line.startsWith('#')) continue;
+
+    const match = line.match(/^([a-zA-Z0-9_-]+)\s*:\s*(.*)$/);
+    if (!match) {
+      throw new Error(`Invalid genome frontmatter line: ${line}`);
+    }
+
+    attributes[match[1]] = parseScalar(match[2]);
+  }
+
+  return {
+    attributes,
+    body: lines.slice(closingIndex + 1).join('\n'),
+    hasFrontmatter: true
+  };
+}
+
+function splitParagraphBlocks(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const blocks = [];
+  let current = [];
+
+  function pushCurrent() {
+    if (current.length === 0) return;
+    const block = current.join('\n').trim();
+    if (block) blocks.push(block);
+    current = [];
+  }
+
+  for (const line of lines) {
+    if (!line.trim()) {
+      pushCurrent();
+      continue;
+    }
+    current.push(line);
+  }
+
+  pushCurrent();
+  return blocks;
+}
+
+function splitSubheadingBlocks(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const blocks = [];
+  let current = [];
+
+  function pushCurrent() {
+    if (current.length === 0) return;
+    const block = current.join('\n').trim();
+    if (block) blocks.push(block);
+    current = [];
+  }
+
+  for (const line of lines) {
+    if (/^###\s+/.test(line.trim())) {
+      pushCurrent();
+      current = [line];
+      continue;
+    }
+
+    if (!line.trim() && current.length === 0) continue;
+    current.push(line);
+  }
+
+  pushCurrent();
+  return blocks;
+}
+
+function splitListBlocks(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const blocks = [];
+  let current = [];
+
+  function pushCurrent() {
+    if (current.length === 0) return;
+    const block = current.join('\n').trim();
+    if (block) blocks.push(block);
+    current = [];
+  }
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const isListStart = /^[-*]\s+/.test(trimmed) || /^\d+\.\s+/.test(trimmed);
+
+    if (isListStart) {
+      pushCurrent();
+      current = [line];
+      continue;
+    }
+
+    if (!trimmed && current.length === 0) continue;
+    current.push(line);
+  }
+
+  pushCurrent();
+  return blocks;
+}
+
+function emptySections() {
+  return GENOME_SECTION_KEYS.reduce((accumulator, key) => {
+    accumulator[key] = [];
+    return accumulator;
+  }, {});
+}
+
+function materializeSection(sectionKey, content) {
+  if (!content.trim()) return [];
+  if (sectionKey === 'mentes') {
+    const blocks = splitSubheadingBlocks(content);
+    return blocks.length > 0 ? blocks : splitParagraphBlocks(content);
+  }
+  if (sectionKey === 'skills') {
+    const blocks = splitListBlocks(content);
+    return blocks.length > 0 ? blocks : splitParagraphBlocks(content);
+  }
+  return splitParagraphBlocks(content);
+}
+
+function parseGenomeSections(markdown) {
+  const sections = emptySections();
+  const lines = String(markdown || '').split(/\r?\n/);
+  let currentSection = null;
+  let buffer = [];
+
+  function flush() {
+    if (!currentSection) {
+      buffer = [];
+      return;
+    }
+    sections[currentSection] = materializeSection(currentSection, buffer.join('\n'));
+    buffer = [];
+  }
+
+  for (const line of lines) {
+    const match = line.match(/^##\s+(.+?)\s*$/);
+    if (match) {
+      flush();
+      currentSection = SECTION_ALIASES.get(normalizeHeading(match[1])) || null;
+      continue;
+    }
+
+    if (!currentSection) continue;
+    buffer.push(line);
+  }
+
+  flush();
+  return sections;
+}
+
+function extractTitle(markdown) {
+  const lines = String(markdown || '').split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/^#\s+(.+?)\s*$/);
+    if (!match) continue;
+    return match[1]
+      .replace(/^(Genome|Genoma)\s*:\s*/i, '')
+      .trim();
+  }
+  return '';
+}
+
+function bodyWithoutTitle(markdown) {
+  const lines = String(markdown || '').split(/\r?\n/);
+  const output = [];
+  let titleSkipped = false;
+
+  for (const line of lines) {
+    if (!titleSkipped && /^#\s+/.test(line.trim())) {
+      titleSkipped = true;
+      continue;
+    }
+    output.push(line);
+  }
+
+  return output.join('\n').trim();
+}
+
+function hasNewSectionContent(sections) {
+  const keys = GENOME_SECTION_KEYS.filter((key) => !['knowledge', 'mentes', 'skills'].includes(key));
+  return keys.some((key) => Array.isArray(sections[key]) && sections[key].length > 0);
+}
+
+function parseGenomeMarkdown(markdown) {
+  const extracted = extractFrontmatter(markdown);
+  const title = extractTitle(extracted.body);
+  const sections = parseGenomeSections(extracted.body);
+  const counts = countGenomeSections({ sections });
+  const hasSectionContent = Object.values(counts).some((count) => count > 0);
+  const fallbackKnowledge = !hasSectionContent ? splitParagraphBlocks(bodyWithoutTitle(extracted.body)) : [];
+  const frontmatter = extracted.attributes;
+
+  const detectedV2 =
+    Number.parseInt(String(frontmatter.version || ''), 10) >= 2 ||
+    ['genome-v2', 'genome-v3'].includes(String(frontmatter.format || '').trim().toLowerCase()) ||
+    Boolean(frontmatter.type) ||
+    Boolean(frontmatter.evidence_mode) ||
+    Boolean(frontmatter.sources_count) ||
+    hasNewSectionContent(sections);
+
+  const genome = normalizeGenome({
+    slug: frontmatter.genome || frontmatter.slug,
+    domain: frontmatter.domain || title,
+    type: frontmatter.type,
+    language: frontmatter.language,
+    depth: frontmatter.depth,
+    evidenceMode: frontmatter.evidence_mode || frontmatter.evidenceMode,
+    sourceCount: frontmatter.sources_count ?? frontmatter.sourceCount,
+    generated: frontmatter.generated,
+    version: frontmatter.version,
+    format: frontmatter.format,
+    personaSource: frontmatter.persona_source || frontmatter.personaSource,
+    personaSources: frontmatter.persona_sources || frontmatter.personaSources,
+    disc: frontmatter.disc,
+    enneagram: frontmatter.enneagram,
+    bigFive: frontmatter.big_five || frontmatter.bigFive,
+    mbti: frontmatter.mbti,
+    confidence: frontmatter.confidence,
+    profilerReport: frontmatter.profiler_report || frontmatter.profilerReport,
+    hybridMode: frontmatter.hybrid_mode || frontmatter.hybridMode,
+    hasFrontmatter: extracted.hasFrontmatter,
+    legacyFormat: !detectedV2,
+    sections: hasSectionContent
+      ? sections
+      : {
+          ...sections,
+          knowledge: fallbackKnowledge
+        }
+  });
+
+  return genome;
+}
+
+function formatFrontmatterValue(value) {
+  if (Array.isArray(value)) return JSON.stringify(value);
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  const text = String(value || '').replace(/\r?\n/g, ' ').trim();
+  if (!text) return '""';
+  if (/[:#]/.test(text)) return JSON.stringify(text);
+  return text;
+}
+
+function renderSectionEntries(entries) {
+  if (!Array.isArray(entries) || entries.length === 0) return '';
+  return entries.map((entry) => String(entry || '').trim()).filter(Boolean).join('\n\n');
+}
+
+function shouldRenderSection(genome, key) {
+  if (['cognitiveProfile', 'communicationStyle', 'biases'].includes(key)) {
+    return genome.version >= 3;
+  }
+
+  if (key === 'conflictResolution') {
+    return genome.version >= 3 && (genome.hybridMode === 'multi-persona' || genome.sections[key].length > 0);
+  }
+
+  return true;
+}
+
+function serializeGenomeMarkdown(input) {
+  const genome = normalizeGenome(input);
+  const counts = countGenomeSections(genome);
+  const generated = genome.generated || new Date().toISOString().slice(0, 10);
+  const frontmatter = [
+    '---',
+    `genome: ${formatFrontmatterValue(genome.slug)}`,
+    `domain: ${formatFrontmatterValue(genome.domain)}`,
+    `type: ${formatFrontmatterValue(genome.type)}`,
+    `language: ${formatFrontmatterValue(genome.language)}`,
+    `depth: ${formatFrontmatterValue(genome.depth)}`,
+    `version: ${formatFrontmatterValue(genome.version)}`,
+    `format: ${formatFrontmatterValue(genome.format)}`,
+    `evidence_mode: ${formatFrontmatterValue(genome.evidenceMode)}`,
+    `generated: ${formatFrontmatterValue(generated)}`,
+    `sources_count: ${formatFrontmatterValue(genome.sourceCount)}`,
+    `mentes: ${formatFrontmatterValue(counts.mentes)}`,
+    `skills: ${formatFrontmatterValue(counts.skills)}`,
+    '---'
+  ];
+
+  if (genome.version >= 3) {
+    frontmatter.splice(
+      frontmatter.length - 1,
+      0,
+      `persona_source: ${formatFrontmatterValue(genome.personaSource)}`,
+      `persona_sources: ${formatFrontmatterValue(genome.personaSources)}`,
+      `disc: ${formatFrontmatterValue(genome.disc)}`,
+      `enneagram: ${formatFrontmatterValue(genome.enneagram)}`,
+      `big_five: ${formatFrontmatterValue(genome.bigFive)}`,
+      `mbti: ${formatFrontmatterValue(genome.mbti)}`,
+      `confidence: ${formatFrontmatterValue(genome.confidence)}`,
+      `profiler_report: ${formatFrontmatterValue(genome.profilerReport)}`,
+      `hybrid_mode: ${formatFrontmatterValue(genome.hybridMode)}`
+    );
+  }
+
+  const parts = [
+    frontmatter.join('\n'),
+    `# Genome: ${genome.domain}`
+  ];
+
+  for (const [key, heading] of SECTION_ORDER) {
+    if (!shouldRenderSection(genome, key)) continue;
+    const body = renderSectionEntries(genome.sections[key]);
+    parts.push(body ? `## ${heading}\n\n${body}` : `## ${heading}`);
+  }
+
+  return `${parts.join('\n\n')}\n`;
+}
+
+function supportsLegacyGenomeMarkdown(markdown) {
+  const genome = parseGenomeMarkdown(markdown);
+  if (!genome.legacyFormat) return false;
+  const counts = countGenomeSections(genome);
+  return counts.knowledgeNodes > 0 || counts.mentes > 0 || counts.skills > 0 || Boolean(genome.domain);
+}
+
+module.exports = {
+  SECTION_ORDER,
+  extractFrontmatter,
+  parseGenomeMarkdown,
+  serializeGenomeMarkdown,
+  parseGenomeSections,
+  supportsLegacyGenomeMarkdown
+};

package/src/genome-schema.js

@@ -0,0 +1,215 @@
+'use strict';
+
+const {
+  GENOME_DEPTHS,
+  GENOME_EVIDENCE_MODES,
+  GENOME_FORMATS,
+  GENOME_CONFIDENCE_LEVELS,
+  GENOME_TYPES,
+  countGenomeSections,
+  normalizeGenome,
+  normalizeGenomeMeta
+} = require('./genomes');
+
+function buildResult(errors, payload, key) {
+  return {
+    valid: errors.length === 0,
+    errors,
+    [key]: payload
+  };
+}
+
+function hasOwn(input, key) {
+  return Boolean(input) && Object.prototype.hasOwnProperty.call(input, key);
+}
+
+function validateEnumField(input, key, allowedValues, errors) {
+  if (!hasOwn(input, key)) return;
+  const value = String(input[key] || '').trim().toLowerCase();
+  if (!value || allowedValues.includes(value)) return;
+  errors.push(`${key} must be one of: ${allowedValues.join(', ')}`);
+}
+
+function validateVersionField(input, key, errors) {
+  if (!hasOwn(input, key)) return;
+  const parsed = Number.parseInt(String(input[key] || ''), 10);
+  if (parsed === 2 || parsed === 3) return;
+  errors.push(`${key} must be 2 or 3`);
+}
+
+function validateFormatAndVersion(normalized, errors, versionKey = 'version', formatKey = 'format') {
+  if (!GENOME_FORMATS.includes(normalized.format)) {
+    errors.push(`${formatKey} must be one of: ${GENOME_FORMATS.join(', ')}`);
+  }
+
+  if (![2, 3].includes(normalized.version)) {
+    errors.push(`${versionKey} must be 2 or 3`);
+  }
+
+  if (normalized.format === 'genome-v3' && normalized.version !== 3) {
+    errors.push('format genome-v3 requires version 3');
+  }
+
+  if (normalized.version === 3 && normalized.format !== 'genome-v3') {
+    errors.push('version 3 requires format genome-v3');
+  }
+}
+
+function validatePersonaV3Requirements(normalized, sections, errors) {
+  if (normalized.version < 3 || normalized.type !== 'persona') return;
+
+  const requiredFields = [
+    ['personaSource', normalized.personaSource],
+    ['disc', normalized.disc],
+    ['enneagram', normalized.enneagram],
+    ['bigFive', normalized.bigFive],
+    ['mbti', normalized.mbti],
+    ['confidence', normalized.confidence],
+    ['profilerReport', normalized.profilerReport]
+  ];
+
+  for (const [key, value] of requiredFields) {
+    if (!String(value || '').trim()) {
+      errors.push(`${key} is required for genome-v3 persona profiles`);
+    }
+  }
+
+  for (const key of ['cognitiveProfile', 'communicationStyle', 'biases']) {
+    if (!Array.isArray(sections[key]) || sections[key].length === 0) {
+      errors.push(`sections.${key} must contain at least one entry for genome-v3 persona profiles`);
+    }
+  }
+}
+
+function validateGenomeObject(input) {
+  const genome = normalizeGenome(input);
+  const errors = [];
+  const sections = input && typeof input.sections === 'object' ? genome.sections : null;
+
+  if (!genome.slug) errors.push('slug is required');
+  if (!genome.domain) errors.push('domain is required');
+  validateEnumField(input, 'type', GENOME_TYPES, errors);
+  validateEnumField(input, 'depth', GENOME_DEPTHS, errors);
+  validateEnumField(input, 'evidenceMode', GENOME_EVIDENCE_MODES, errors);
+  validateEnumField(input, 'evidence_mode', GENOME_EVIDENCE_MODES, errors);
+  validateEnumField(input, 'confidence', GENOME_CONFIDENCE_LEVELS, errors);
+  validateVersionField(input, 'version', errors);
+  if (hasOwn(input, 'format')) {
+    const value = String(input.format || '').trim().toLowerCase();
+    if (!GENOME_FORMATS.includes(value)) {
+      errors.push(`format must be one of: ${GENOME_FORMATS.join(', ')}`);
+    }
+  }
+  validateFormatAndVersion(genome, errors);
+
+  if (!sections) {
+    errors.push('sections must be an object');
+  } else {
+    for (const key of ['knowledge', 'mentes', 'skills', 'cognitiveProfile', 'communicationStyle', 'biases', 'conflictResolution']) {
+      if (!Array.isArray(sections[key])) {
+        errors.push(`sections.${key} must be an array`);
+      }
+    }
+  }
+
+  validatePersonaV3Requirements(genome, genome.sections, errors);
+
+  return buildResult(errors, genome, 'genome');
+}
+
+function validateGenomeMeta(input) {
+  const meta = normalizeGenomeMeta(input);
+  const errors = [];
+
+  if (!hasOwn(input, 'schemaVersion') || ![2, 3].includes(Number.parseInt(String(input.schemaVersion), 10))) {
+    errors.push('schemaVersion must be 2 or 3');
+  }
+  validateVersionField(input, 'version', errors);
+  if (hasOwn(input, 'format')) {
+    const value = String(input.format || '').trim().toLowerCase();
+    if (!GENOME_FORMATS.includes(value)) {
+      errors.push(`format must be one of: ${GENOME_FORMATS.join(', ')}`);
+    }
+  }
+  validateFormatAndVersion(meta, errors);
+  if (!meta.slug) errors.push('slug is required');
+  if (!meta.domain) errors.push('domain is required');
+  validateEnumField(input, 'type', GENOME_TYPES, errors);
+  validateEnumField(input, 'depth', GENOME_DEPTHS, errors);
+  validateEnumField(input, 'evidenceMode', GENOME_EVIDENCE_MODES, errors);
+  validateEnumField(input, 'evidence_mode', GENOME_EVIDENCE_MODES, errors);
+  validateEnumField(input, 'confidence', GENOME_CONFIDENCE_LEVELS, errors);
+  if (!meta.counts || typeof meta.counts !== 'object') {
+    errors.push('counts must be an object');
+  } else {
+    const counts = countGenomeSections({
+      sections: {
+        knowledge: Array(meta.counts.knowledgeNodes).fill('x'),
+        philosophies: Array(meta.counts.philosophies).fill('x'),
+        mentalModels: Array(meta.counts.mentalModels).fill('x'),
+        heuristics: Array(meta.counts.heuristics).fill('x'),
+        frameworks: Array(meta.counts.frameworks).fill('x'),
+        methodologies: Array(meta.counts.methodologies).fill('x'),
+        mentes: Array(meta.counts.mentes).fill('x'),
+        skills: Array(meta.counts.skills).fill('x'),
+        cognitiveProfile: Array(meta.counts.cognitiveProfile).fill('x'),
+        communicationStyle: Array(meta.counts.communicationStyle).fill('x'),
+        biases: Array(meta.counts.biases).fill('x'),
+        conflictResolution: Array(meta.counts.conflictResolution).fill('x'),
+        evidence: Array(meta.counts.evidence).fill('x'),
+        applicationNotes: Array(meta.counts.applicationNotes).fill('x')
+      }
+    });
+    for (const key of Object.keys(counts)) {
+      if (counts[key] !== meta.counts[key]) {
+        errors.push(`counts.${key} must be a non-negative integer`);
+      }
+    }
+  }
+  if (!meta.createdAt) errors.push('createdAt is required');
+  if (!meta.updatedAt) errors.push('updatedAt is required');
+  validatePersonaV3Requirements(
+    {
+      version: meta.version,
+      type: meta.type,
+      personaSource: meta.personaSource,
+      disc: meta.disc,
+      enneagram: meta.enneagram,
+      bigFive: meta.bigFive,
+      mbti: meta.mbti,
+      confidence: meta.confidence,
+      profilerReport: meta.profilerReport
+    },
+    {
+      cognitiveProfile: Array(meta.counts.cognitiveProfile).fill('x'),
+      communicationStyle: Array(meta.counts.communicationStyle).fill('x'),
+      biases: Array(meta.counts.biases).fill('x')
+    },
+    errors
+  );
+
+  return buildResult(errors, meta, 'meta');
+}
+
+function assertValidGenome(input) {
+  const result = validateGenomeObject(input);
+  if (!result.valid) {
+    throw new Error(`Invalid genome: ${result.errors.join('; ')}`);
+  }
+  return result.genome;
+}
+
+function assertValidGenomeMeta(input) {
+  const result = validateGenomeMeta(input);
+  if (!result.valid) {
+    throw new Error(`Invalid genome meta: ${result.errors.join('; ')}`);
+  }
+  return result.meta;
+}
+
+module.exports = {
+  validateGenomeObject,
+  validateGenomeMeta,
+  assertValidGenome,
+  assertValidGenomeMeta
+};