sinapse-ai 1.12.2 → 1.14.0

package/.sinapse-ai/development/scripts/yaml-validator.js

@@ -1,397 +0,0 @@
-/**
- * YAML Validator for SINAPSE Developer Meta-Agent
- * Ensures YAML files maintain proper structure and syntax
- */
-
-const yaml = require('js-yaml');
-const fs = require('fs-extra');
-
-class YAMLValidator {
-  constructor() {
-    this.validationRules = {
-      agent: {
-        required: ['agent', 'persona', 'commands'],
-        optional: ['dependencies', 'security', 'customization'],
-        structure: {
-          agent: {
-            required: ['name', 'id', 'title', 'icon', 'whenToUse'],
-            optional: ['customization']
-          },
-          persona: {
-            required: ['role', 'style', 'identity', 'focus'],
-            optional: []
-          }
-        }
-      },
-      manifest: {
-        required: ['bundle', 'agents'],
-        optional: ['workflows'],
-        structure: {
-          bundle: {
-            required: ['name', 'icon', 'description'],
-            optional: []
-          }
-        }
-      },
-      workflow: {
-        required: ['workflow', 'stages'],
-        optional: ['transitions', 'resources', 'validation'],
-        structure: {
-          workflow: {
-            required: ['id', 'name', 'description', 'type', 'scope'],
-            optional: []
-          }
-        }
-      }
-    };
-  }
-
-  /**
-   * Validate YAML content
-   */
-  async validate(content, type = 'general') {
-    const results = {
-      valid: true,
-      errors: [],
-      warnings: [],
-      parsed: null
-    };
-
-    try {
-      // Parse YAML
-      results.parsed = yaml.load(content, {
-        schema: yaml.SAFE_SCHEMA,
-        onWarning: (warning) => {
-          results.warnings.push({
-            type: 'yaml_warning',
-            message: warning.toString()
-          });
-        }
-      });
-
-      // Type-specific validation
-      if (type !== 'general' && this.validationRules[type]) {
-        this.validateStructure(results.parsed, type, results);
-      }
-
-      // General validations
-      this.validateGeneral(results.parsed, results);
-
-    } catch (error) {
-      results.valid = false;
-      results.errors.push({
-        type: 'parse_error',
-        message: error.message,
-        line: error.mark ? error.mark.line : null,
-        column: error.mark ? error.mark.column : null
-      });
-    }
-
-    return results;
-  }
-
-  /**
-   * Validate YAML file
-   */
-  async validateFile(filePath, type = 'general') {
-    try {
-      const content = await fs.readFile(filePath, 'utf8');
-      const results = await this.validate(content, type);
-      results.filePath = filePath;
-      return results;
-    } catch (error) {
-      return {
-        valid: false,
-        filePath,
-        errors: [{
-          type: 'file_error',
-          message: `Could not read file: ${error.message}`
-        }]
-      };
-    }
-  }
-
-  /**
-   * Validate structure based on type
-   */
-  validateStructure(data, type, results) {
-    const rules = this.validationRules[type];
-
-    // Check required top-level fields
-    for (const field of rules.required) {
-      if (!data.hasOwnProperty(field)) {
-        results.valid = false;
-        results.errors.push({
-          type: 'missing_required',
-          field,
-          message: `Missing required field: ${field}`
-        });
-      }
-    }
-
-    // Check structure of specific fields
-    if (rules.structure) {
-      for (const [field, fieldRules] of Object.entries(rules.structure)) {
-        if (data[field]) {
-          this.validateFieldStructure(
-            data[field], 
-            field, 
-            fieldRules, 
-            results
-          );
-        }
-      }
-    }
-
-    // Warn about unknown fields
-    const allKnownFields = [
-      ...(rules.required || []),
-      ...(rules.optional || [])
-    ];
-    
-    for (const field of Object.keys(data)) {
-      if (!allKnownFields.includes(field)) {
-        results.warnings.push({
-          type: 'unknown_field',
-          field,
-          message: `Unknown field: ${field}`
-        });
-      }
-    }
-  }
-
-  /**
-   * Validate field structure
-   */
-  validateFieldStructure(data, fieldName, rules, results) {
-    // Check required subfields
-    for (const subfield of rules.required || []) {
-      if (!data.hasOwnProperty(subfield)) {
-        results.valid = false;
-        results.errors.push({
-          type: 'missing_required',
-          field: `${fieldName}.${subfield}`,
-          message: `Missing required field: ${fieldName}.${subfield}`
-        });
-      }
-    }
-
-    // Check field types
-    this.validateFieldTypes(data, fieldName, results);
-  }
-
-  /**
-   * Validate field types
-   */
-  validateFieldTypes(data, fieldName, results) {
-    for (const [key, value] of Object.entries(data)) {
-      const fullPath = `${fieldName}.${key}`;
-      
-      // Check for null/undefined
-      if (value === null || value === undefined) {
-        results.warnings.push({
-          type: 'null_value',
-          field: fullPath,
-          message: `Null or undefined value at ${fullPath}`
-        });
-      }
-
-      // Type-specific checks
-      if (key === 'id' || key === 'name') {
-        if (typeof value !== 'string' || value.trim() === '') {
-          results.errors.push({
-            type: 'invalid_type',
-            field: fullPath,
-            message: `${fullPath} must be a non-empty string`
-          });
-        }
-      }
-
-      if (key === 'icon' && typeof value === 'string') {
-        // Check if it's a valid emoji or icon string
-        if (value.length === 0) {
-          results.warnings.push({
-            type: 'empty_icon',
-            field: fullPath,
-            message: 'Icon field is empty'
-          });
-        }
-      }
-    }
-  }
-
-  /**
-   * General validations for all YAML
-   */
-  validateGeneral(data, results) {
-    // Check for circular references
-    try {
-      JSON.stringify(data);
-    } catch (error) {
-      if (error.message.includes('circular')) {
-        results.valid = false;
-        results.errors.push({
-          type: 'circular_reference',
-          message: 'Circular reference detected in YAML structure'
-        });
-      }
-    }
-
-    // Check for excessively deep nesting
-    const maxDepth = this.getMaxDepth(data);
-    if (maxDepth > 10) {
-      results.warnings.push({
-        type: 'deep_nesting',
-        depth: maxDepth,
-        message: `Deep nesting detected (${maxDepth} levels)`
-      });
-    }
-  }
-
-  /**
-   * Get maximum depth of object
-   */
-  getMaxDepth(obj, currentDepth = 0) {
-    if (typeof obj !== 'object' || obj === null) {
-      return currentDepth;
-    }
-
-    let maxDepth = currentDepth;
-    for (const value of Object.values(obj)) {
-      if (typeof value === 'object') {
-        const depth = this.getMaxDepth(value, currentDepth + 1);
-        maxDepth = Math.max(maxDepth, depth);
-      }
-    }
-
-    return maxDepth;
-  }
-
-  /**
-   * Fix common YAML issues
-   */
-  async autoFix(content, type = 'general') {
-    let fixed = content;
-
-    // Fix common indentation issues
-    fixed = this.fixIndentation(fixed);
-
-    // Fix quote issues
-    fixed = this.fixQuotes(fixed);
-
-    // Validate the fixed content
-    const validation = await this.validate(fixed, type);
-    
-    return {
-      content: fixed,
-      validation,
-      changed: content !== fixed
-    };
-  }
-
-  /**
-   * Fix indentation issues
-   * @param {string} content - YAML content to fix
-   * @returns {string} Fixed YAML content
-   */
-  fixIndentation(content) {
-    const lines = content.split('\n');
-    const fixedLines = [];
-    const indentStack = [0];
-    let currentLevel = 0;
-
-    for (let i = 0; i < lines.length; i++) {
-      const line = lines[i];
-      const trimmed = line.trim();
-      
-      // Skip empty lines and comments
-      if (!trimmed || trimmed.startsWith('#')) {
-        fixedLines.push(line);
-        continue;
-      }
-
-      // Handle list items
-      if (trimmed.startsWith('-')) {
-        const baseIndent = indentStack[indentStack.length - 1];
-        fixedLines.push(' '.repeat(baseIndent) + trimmed);
-        
-        // If list item has a key-value pair, prepare for nested content
-        if (trimmed.includes(':') && !trimmed.endsWith(':')) {
-          const afterDash = trimmed.substring(1).trim();
-          if (afterDash.includes(':')) {
-            currentLevel = baseIndent + 2;
-          }
-        }
-      }
-      // Handle key-value pairs
-      else if (trimmed.includes(':')) {
-        // Find appropriate indent level
-        const colonIndex = trimmed.indexOf(':');
-        const _key = trimmed.substring(0, colonIndex);
-        
-        // Pop stack until we find the right level
-        while (indentStack.length > 1 && 
-               line.length - line.trimStart().length < indentStack[indentStack.length - 1]) {
-          indentStack.pop();
-        }
-        
-        currentLevel = indentStack[indentStack.length - 1];
-        fixedLines.push(' '.repeat(currentLevel) + trimmed);
-        
-        // If this opens a new block, push new indent level
-        if (trimmed.endsWith(':') || (i + 1 < lines.length && lines[i + 1].trim() && 
-            lines[i + 1].length - lines[i + 1].trimStart().length > currentLevel)) {
-          indentStack.push(currentLevel + 2);
-        }
-      } else {
-        // Regular content line
-        fixedLines.push(' '.repeat(currentLevel) + trimmed);
-      }
-    }
-
-    return fixedLines.join('\n');
-  }
-
-  /**
-   * Fix quote issues
-   */
-  fixQuotes(content) {
-    // Fix unquoted strings that need quotes
-    return content.replace(
-      /^(\s*\w+):\s*([^"'\n]*[:{}\[\]|>&*!%@`][^"'\n]*)$/gm,
-      '$1: "$2"'
-    );
-  }
-
-  /**
-   * Generate validation report
-   */
-  generateReport(validation) {
-    const report = [];
-    
-    report.push(`YAML Validation Report`);
-    report.push(`=====================`);
-    report.push(`Valid: ${validation.valid ? '✅ Yes' : '❌ No'}`);
-    
-    if (validation.errors.length > 0) {
-      report.push(`\nErrors (${validation.errors.length}):`);
-      for (const error of validation.errors) {
-        report.push(`  - ${error.message}`);
-        if (error.line) {
-          report.push(`    Line: ${error.line}, Column: ${error.column}`);
-        }
-      }
-    }
-
-    if (validation.warnings.length > 0) {
-      report.push(`\nWarnings (${validation.warnings.length}):`);
-      for (const warning of validation.warnings) {
-        report.push(`  - ${warning.message}`);
-      }
-    }
-
-    return report.join('\n');
-  }
-}
-
-module.exports = YAMLValidator;

package/.sinapse-ai/hooks/sinapse-brand-grounding.cjs

@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * SINAPSE Brand Grounding Hook — UserPromptSubmit (framework-shipped).
- *
- * @story GA-1.6
- *
- * Reads `~/.claude/sinapse-ai-config.yaml` `brand` section and, when enabled,
- * injects the first 2000 chars of the user's brandbook as `<brand-grounding>`
- * context.
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const HOOK_TIMEOUT_MS = 3500;
-const MAX_INJECTION_SIZE = 2000;
-const MAX_BRAND_PREVIEW = 2000;
-const MIN_PROMPT_CHARS = 10;
-const CONFIG_PATH = path.join(os.homedir(), '.claude', 'sinapse-ai-config.yaml');
-
-function readStdin() {
-  return new Promise((resolve) => {
-    let data = '';
-    let settled = false;
-    const finish = (val) => { if (!settled) { settled = true; resolve(val); } };
-    try {
-      process.stdin.setEncoding('utf8');
-      process.stdin.on('error', () => finish(null));
-      process.stdin.on('data', (chunk) => { data += chunk; });
-      process.stdin.on('end', () => {
-        try { finish(JSON.parse(data)); } catch { finish(null); }
-      });
-    } catch {
-      finish(null);
-    }
-  });
-}
-
-// Story 10.47: delegate to the shared grounding config loader instead of
-// duplicating the read+parse. The require is guarded so the hook stays
-// fail-open even if the shared module is somehow absent at runtime.
-function loadConfig() {
-  try {
-    return require('../core/grounding/config-loader.cjs').loadGroundingConfig(CONFIG_PATH);
-  } catch {
-    return null;
-  }
-}
-
-function getSection(cfg, name) {
-  if (!cfg || !cfg.grounding) return null;
-  const s = cfg.grounding[name];
-  if (!s || typeof s !== 'object' || !s.enabled) return null;
-  return s;
-}
-
-function readBrandbook(brandbookPath) {
-  try {
-    if (!brandbookPath || !fs.existsSync(brandbookPath)) return null;
-    const stat = fs.statSync(brandbookPath);
-    let target = brandbookPath;
-    if (stat.isDirectory()) {
-      const candidates = ['brandbook.md', 'README.md', 'guidelines.md', 'brand.md'];
-      target = null;
-      for (const c of candidates) {
-        const full = path.join(brandbookPath, c);
-        if (fs.existsSync(full)) { target = full; break; }
-      }
-      if (!target) {
-        const mds = fs.readdirSync(brandbookPath).filter((f) => f.endsWith('.md'));
-        if (mds.length > 0) target = path.join(brandbookPath, mds[0]);
-      }
-      if (!target) return null;
-    }
-    let content = fs.readFileSync(target, 'utf8');
-    if (content.length > MAX_BRAND_PREVIEW) {
-      content = content.substring(0, MAX_BRAND_PREVIEW) + '\n[...truncated...]';
-    }
-    return content;
-  } catch {
-    return null;
-  }
-}
-
-function buildInjection(section, brandContent) {
-  const profileName = section.profileName || 'Custom Brand';
-  const parts = [];
-  parts.push(`<brand-grounding name="${profileName}">`);
-  parts.push(`Brand detectada: ${profileName}`);
-  if (brandContent) {
-    parts.push('--- BRANDBOOK (primeiros 2000 chars) ---');
-    parts.push(brandContent);
-  } else {
-    parts.push('(brandbookPath nao encontrado ou vazio)');
-  }
-  parts.push('</brand-grounding>');
-
-  let full = parts.join('\n');
-  if (full.length > MAX_INJECTION_SIZE) {
-    const trailer = '\n[...truncated...]\n</brand-grounding>';
-    full = full.substring(0, MAX_INJECTION_SIZE - trailer.length) + trailer;
-  }
-  return full;
-}
-
-async function main() {
-  const input = await readStdin();
-  if (!input || typeof input !== 'object') return;
-
-  const userPrompt = input.prompt || input.user_prompt || input.message || '';
-  if (typeof userPrompt !== 'string' || userPrompt.trim().length < MIN_PROMPT_CHARS) return;
-
-  // Anti-double-injection
-  if (userPrompt.includes('<brand-grounding')) return;
-
-  const cfg = loadConfig();
-  const section = getSection(cfg, 'brand');
-  if (!section || !section.brandbookPath) return;
-
-  const brandContent = readBrandbook(section.brandbookPath);
-  const context = buildInjection(section, brandContent);
-
-  const output = JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: 'UserPromptSubmit',
-      additionalContext: context,
-    },
-  });
-
-  await new Promise((resolve) => {
-    let settled = false;
-    const finish = () => { if (!settled) { settled = true; resolve(); } };
-    try {
-      const flushed = process.stdout.write(output, () => finish());
-      if (flushed) setImmediate(finish);
-    } catch {
-      finish();
-    }
-  });
-}
-
-function run() {
-  const timer = setTimeout(() => process.exit(0), HOOK_TIMEOUT_MS);
-  timer.unref();
-  main()
-    .then(() => { clearTimeout(timer); process.exitCode = 0; })
-    .catch(() => { clearTimeout(timer); process.exitCode = 0; });
-}
-
-if (require.main === module) run();
-
-module.exports = {
-  loadConfig,
-  getSection,
-  readBrandbook,
-  buildInjection,
-  CONFIG_PATH,
-  MAX_INJECTION_SIZE,
-};