clckernel 1.2.6

package/src/technologies/detector.js

@@ -0,0 +1,243 @@
+/**
+ * CLC Forge — TechnologyDetector
+ * Detects Phase-1 technologies (Celery, Redis, PostgreSQL, Docker) via file signatures.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @typedef {'celery' | 'redis' | 'postgresql' | 'docker'} Technology
+ */
+
+/**
+ * TechnologyDetector scans a project root for Phase-1 technology signatures.
+ */
+class TechnologyDetector {
+  /**
+   * Detect which Phase-1 technologies are present in targetDir.
+   * @param {string} targetDir - Project root path
+   * @returns {Technology[]} Array of detected technology identifiers
+   */
+  detect(targetDir) {
+    /** @type {Technology[]} */
+    const detected = [];
+
+    try {
+      if (!fs.existsSync(targetDir)) {
+        return [];
+      }
+
+      // Celery detection
+      if (this._detectCelery(targetDir)) {
+        detected.push('celery');
+      }
+
+      // Redis detection
+      if (this._detectRedis(targetDir)) {
+        detected.push('redis');
+      }
+
+      // PostgreSQL detection
+      if (this._detectPostgresql(targetDir)) {
+        detected.push('postgresql');
+      }
+
+      // Docker detection
+      if (this._detectDocker(targetDir)) {
+        detected.push('docker');
+      }
+    } catch (err) {
+      console.warn(`[TechnologyDetector] Error during detection: ${err.message}`);
+    }
+
+    return detected;
+  }
+
+  /**
+   * @param {string} targetDir
+   * @returns {boolean}
+   */
+  _detectCelery(targetDir) {
+    // Check requirements.txt
+    if (this._matchInFile(targetDir, 'requirements.txt', 'celery')) {
+      return true;
+    }
+
+    // Check pyproject.toml
+    if (this._matchInFile(targetDir, 'pyproject.toml', 'celery')) {
+      return true;
+    }
+
+    // Check celery.py or celeryconfig.py
+    const celeryFiles = ['celery.py', 'celeryconfig.py', 'celery_app.py'];
+    for (const file of celeryFiles) {
+      if (fs.existsSync(path.join(targetDir, file))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * @param {string} targetDir
+   * @returns {boolean}
+   */
+  _detectRedis(targetDir) {
+    // Check requirements.txt
+    if (this._matchInFile(targetDir, 'requirements.txt', 'redis')) {
+      return true;
+    }
+
+    // Check pyproject.toml
+    if (this._matchInFile(targetDir, 'pyproject.toml', 'redis')) {
+      return true;
+    }
+
+    // Check redis.conf
+    if (fs.existsSync(path.join(targetDir, 'redis.conf'))) {
+      return true;
+    }
+
+    // Check for redis:// URL in .env files
+    if (this._containsRedisUrl(targetDir)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * @param {string} targetDir
+   * @returns {boolean}
+   */
+  _detectPostgresql(targetDir) {
+    // Check for psycopg2, asyncpg, or psycopg2-binary
+    const pgPackages = ['psycopg2', 'asyncpg', 'psycopg2-binary'];
+
+    for (const pkg of pgPackages) {
+      if (this._matchInFile(targetDir, 'requirements.txt', pkg)) {
+        return true;
+      }
+      if (this._matchInFile(targetDir, 'pyproject.toml', pkg)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * @param {string} targetDir
+   * @returns {boolean}
+   */
+  _detectDocker(targetDir) {
+    if (fs.existsSync(path.join(targetDir, 'Dockerfile'))) {
+      return true;
+    }
+    if (fs.existsSync(path.join(targetDir, 'docker-compose.yml'))) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if a file exists and contains a case-insensitive substring.
+   * @param {string} targetDir
+   * @param {string} filename
+   * @param {string} pattern
+   * @returns {boolean}
+   */
+  _matchInFile(targetDir, filename, pattern) {
+    const filePath = path.join(targetDir, filename);
+    if (!fs.existsSync(filePath)) {
+      return false;
+    }
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return content.toLowerCase().includes(pattern.toLowerCase());
+    } catch (err) {
+      console.warn(`[TechnologyDetector] Could not read ${filePath}: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Check for redis:// URL in .env files.
+   * @param {string} targetDir
+   * @returns {boolean}
+   */
+  _containsRedisUrl(targetDir) {
+    try {
+      const entries = fs.readdirSync(targetDir);
+      for (const entry of entries) {
+        if (entry === '.env' || entry.startsWith('.env.')) {
+          const filePath = path.join(targetDir, entry);
+          const content = fs.readFileSync(filePath, 'utf-8');
+          if (content.toLowerCase().includes('redis://')) {
+            return true;
+          }
+        }
+      }
+    } catch (err) {
+      // Ignore read errors
+    }
+    return false;
+  }
+
+  /**
+   * Returns tool manifest entries for detected technologies.
+   * @param {Technology[]} technologies
+   * @returns {Array<{name: string, language: string, path: string, command: string, description: string}>}
+   */
+  getToolsForTech(technologies) {
+    /** @type {Array<{name: string, language: string, path: string, command: string, description: string}>} */
+    const tools = [];
+
+    for (const tech of technologies) {
+      switch (tech) {
+        case 'celery':
+          tools.push({
+            name: 'celery_guard',
+            language: 'py',
+            path: 'celery_guard.py',
+            command: 'python3 tools/celery_guard.py',
+            description: 'Celery guard: broker URL exposure, missing ignore_result on @shared_task, hardcoded result backend',
+          });
+          break;
+        case 'redis':
+          tools.push({
+            name: 'redis_guard',
+            language: 'py',
+            path: 'redis_guard.py',
+            command: 'python3 tools/redis_guard.py',
+            description: 'Redis guard: decode_responses without password check, missing socket_connect_timeout, hardcoded Redis URLs',
+          });
+          break;
+        case 'postgresql':
+          tools.push({
+            name: 'postgres_guard',
+            language: 'py',
+            path: 'postgres_guard.py',
+            command: 'python3 tools/postgres_guard.py',
+            description: 'PostgreSQL guard: raw SQL with string formatting, hstore raw usage',
+          });
+          break;
+        case 'docker':
+          tools.push({
+            name: 'docker_guard',
+            language: 'py',
+            path: 'docker_guard.py',
+            command: 'python3 tools/docker_guard.py',
+            description: 'Docker guard: non-root USER, ENV secrets exposure, missing HEALTHCHECK',
+          });
+          break;
+      }
+    }
+
+    return tools;
+  }
+}
+
+module.exports = { TechnologyDetector };

package/src/technologies/guards/_shared.js

@@ -0,0 +1,66 @@
+/**
+ * CLC Forge — Shared Guard Utilities
+ * Common file-reading and result-formatting helpers for technology guards.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Read file content if it exists, otherwise return null.
+ * @param {string} filePath
+ * @returns {string | null}
+ */
+function readFileIfExists(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    console.warn(`[_shared] Could not read ${filePath}: ${err.message}`);
+    return null;
+  }
+}
+
+/**
+ * Check if a pattern matches in file content (case-insensitive).
+ * @param {string} pattern - Substring to search for
+ * @param {string | null} content - File content or null
+ * @returns {boolean}
+ */
+function matchInFile(pattern, content) {
+  if (content === null) {
+    return false;
+  }
+  return content.toLowerCase().includes(pattern.toLowerCase());
+}
+
+/**
+ * Format a standard guard result.
+ * @param {string} name - Guard name
+ * @param {Array<object>} violations - List of violation findings
+ * @param {boolean} skipped - Whether guard was skipped
+ * @param {string} [message] - Optional human-readable summary
+ * @returns {object} Standard guard result
+ */
+function formatResult(name, violations, skipped, message) {
+  const hasViolations = violations.length > 0;
+  const exitCode = hasViolations ? 1 : 0;
+
+  return {
+    exit_code: exitCode,
+    skipped: skipped,
+    name: name,
+    data: {
+      findings: violations,
+      message: message || (skipped
+        ? 'Guard skipped'
+        : hasViolations
+          ? `${violations.length} violation(s) found`
+          : 'No violations found'),
+    },
+  };
+}
+
+module.exports = { readFileIfExists, matchInFile, formatResult };

package/src/ui.js

@@ -0,0 +1,101 @@
+/**
+ * CLC Kernel — Pro Terminal UI & ANSI Renderer
+ * Brand Identity: The AI Agent Governance & Quality Engineering Engine
+ */
+
+const readline = require('readline');
+
+// ANSI Color Palette
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  cyan: '\x1b[36m',
+  emerald: '\x1b[32m',
+  violet: '\x1b[35m',
+  amber: '\x1b[33m',
+  red: '\x1b[31m',
+  blue: '\x1b[34m',
+  gray: '\x1b[90m',
+  bgCyan: '\x1b[46m\x1b[30m',
+  bgViolet: '\x1b[45m\x1b[30m',
+  bgEmerald: '\x1b[42m\x1b[30m'
+};
+
+function printBanner() {
+  console.clear();
+  console.log(`${colors.cyan}
+   ██████╗██╗      ██████╗     ██╗  ██╗███████╗██████╗ ███╗   ██╗███████╗██╗     
+  ██╔════╝██║     ██╔════╝     ██║ ██╔╝██╔════╝██╔══██╗████╗  ██║██╔════╝██║     
+  ██║     ██║     ██║    █████╗█████═╝ █████╗  ██████╔╝██╔██╗ ██║█████╗  ██║     
+  ██║     ██║     ██║    ╚════╝██╔═██╗ ██╔══╝  ██╔══██╗██║╚██╗██║██╔══╝  ██║     
+  ╚██████╗███████╗╚██████╗     ██║ ╚██╗███████╗██║  ██║██║ ╚████║███████╗███████╗
+   ╚═════╝╚══════╝ ╚═════╝     ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝╚══════╝╚══════╝
+${colors.reset}`);
+  console.log(`  ${colors.bgCyan} CLC KERNEL ${colors.reset} ${colors.bold}The AI Agent Governance & Quality Engineering Engine${colors.reset} ${colors.gray}v1.2.4${colors.reset}\n`);
+}
+
+function printBox(title, items) {
+  const width = 68;
+  console.log(`${colors.dim}┌${'─'.repeat(width)}┐${colors.reset}`);
+  console.log(`${colors.dim}│${colors.reset}  ${colors.bold}${colors.cyan}${title.padEnd(width - 4)}${colors.reset}  ${colors.dim}│${colors.reset}`);
+  console.log(`${colors.dim}├${'─'.repeat(width)}┤${colors.reset}`);
+
+  items.forEach(({ label, value, badgeColor = colors.emerald }) => {
+    const line = ` ${colors.gray}${label.padEnd(22)}:${colors.reset} ${badgeColor}${colors.bold}${value}${colors.reset}`;
+    const plainLength = `${label} : ${value}`.length;
+    const padding = Math.max(0, width - plainLength - 3);
+    console.log(`${colors.dim}│${colors.reset} ${line}${' '.repeat(padding)}${colors.dim}│${colors.reset}`);
+  });
+
+  console.log(`${colors.dim}└${'─'.repeat(width)}┘${colors.reset}\n`);
+}
+
+function promptOptions(detected) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log(`${colors.bold}   \x1b[32m[1]\x1b[0m Confirmar e Instalar CLC Kernel ${colors.dim}(Recomendado)${colors.reset}`);
+    console.log(`   \x1b[33m[2]\x1b[0m Forzar modo FRONTEND`);
+    console.log(`   \x1b[33m[3]\x1b[0m Forzar modo BACKEND`);
+    console.log(`   \x1b[90m[4] Cancelar${colors.reset}\n`);
+
+    rl.question(`${colors.cyan}${colors.bold}➔ Seleccioná una opción [1]: ${colors.reset}`, (answer) => {
+      const choice = answer.trim() || '1';
+      rl.close();
+
+      if (choice === '1') {
+        resolve(detected);
+      } else if (choice === '2') {
+        detected.projectType = 'frontend';
+        resolve(detected);
+      } else if (choice === '3') {
+        detected.projectType = 'backend';
+        resolve(detected);
+      } else {
+        console.log(`\n${colors.red}❌ Instalación de CLC Kernel cancelada.${colors.reset}`);
+        process.exit(0);
+      }
+    });
+  });
+}
+
+function printSuccess(targetDir, isFront, config) {
+  console.log(`\n${colors.bgEmerald} SUCCESS ${colors.reset} ${colors.bold}${colors.emerald}¡CLC Kernel instalado exitosamente!${colors.reset}\n`);
+  console.log(` 🔨 ${colors.bold}Proyecto Inicializado:${colors.reset} ${colors.cyan}${targetDir}${colors.reset}`);
+  console.log(` 🛡️  ${colors.bold}Salvaguardas:${colors.reset} ${isFront ? `${colors.emerald}10 Guardias Frontend (A11y, Zod, Next/Image, UI Reuse, Storybook)` : `${colors.violet}7 Guardias Backend (TDD, Architecture, Scope, Secret Scan)`}${colors.reset}`);
+  console.log(` 📝 ${colors.bold}Leyes & SDD:${colors.reset} AGENTS.md, sdds/, docs/Journal/ precargados`);
+  console.log(` 🔒 ${colors.bold}Git Hooks:${colors.reset} Configurados en ${colors.amber}${config.gitHooks === 'husky' ? '.husky/pre-commit' : '.githooks/pre-commit'}${colors.reset}\n`);
+}
+
+module.exports = {
+  colors,
+  printBanner,
+  printBox,
+  promptOptions,
+  printSuccess
+};

package/src/yaml.js

@@ -0,0 +1,173 @@
+/**
+ * CLC Forge — Zero-Dependency YAML Parser
+ * Self-contained inline YAML parser extracted from tools/check_custom.js.
+ * Uses only Node.js built-ins (no npm deps).
+ *
+ * Supports: scalars, block sequences, block mappings, inline flow
+ * sequences/mappings, comments. No anchors/aliases, no multiple documents.
+ *
+ * Stack entries: { obj, indent, _parentObj, _parentKey }
+ *   obj: the object we are building key-value pairs into
+ *   indent: indent level (children at same indent stay)
+ *   _parentObj/_parentKey: where to find/create the array for sequences
+ *
+ * @module yaml
+ */
+
+/**
+ * Detect YAML anchors (`&name`) or aliases (`*name`) on a line.
+ * @param {string} line - Trimmed content of a YAML line.
+ * @param {number} lineNo - 1-based line number for error reporting.
+ * @throws {Error} If anchor or alias syntax is found (unsupported).
+ */
+function assertNoAnchorAlias(line, lineNo) {
+  // YAML anchors/aliases are token-boundary markers: `&name` / `*name`
+  // preceded by whitespace or start of line. Requiring the boundary avoids
+  // false positives on regex/glob content such as `pattern: 'a*b'`.
+  if (/(?:^|\s)[&*][A-Za-z0-9_-]/.test(line)) {
+    throw new Error(
+      `Unsupported YAML syntax at line ${lineNo}: anchors/aliases are not supported`
+    );
+  }
+}
+
+/**
+ * Parse a YAML string into a JavaScript object.
+ * Throws on anchors/aliases (unsupported).
+ * @param {string} text - Raw YAML source.
+ * @returns {object} Parsed object tree.
+ */
+function parseYaml(text) {
+  const lines = text.split('\n');
+  const root = {};
+  const stack = [{ obj: root, indent: -1, _parentObj: null, _parentKey: null }];
+
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i].replace(/\s*#.*$/, '').trimEnd();
+    if (line.trim() === '' || line.trim().startsWith('#')) continue;
+
+    const indent = line.search(/\S/);
+    const trimmed = line.trim();
+
+    // New behavior: anchors/aliases are unsupported
+    assertNoAnchorAlias(trimmed, i + 1);
+
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const entry = stack[stack.length - 1];
+
+    // ── Sequence item: "- rest" ──
+    if (trimmed.startsWith('- ')) {
+      const rest = trimmed.slice(2).trim();
+
+      if (rest.includes(': ')) {
+        // "- key: value" — mapping inside a sequence
+        let arr = null;
+        // Check if parent key already points to an array
+        if (entry._parentObj && entry._parentKey) {
+          const pk = entry._parentObj[entry._parentKey];
+          if (Array.isArray(pk)) {
+            arr = pk;
+          } else if (pk && typeof pk === 'object' && Object.keys(pk).length === 0) {
+            // Convert empty object to array
+            entry._parentObj[entry._parentKey] = [];
+            arr = entry._parentObj[entry._parentKey];
+          }
+        }
+        if (arr) {
+          const obj = {};
+          const colonIdx = rest.indexOf(': ');
+          obj[rest.slice(0, colonIdx).trim()] = parseScalar(rest.slice(colonIdx + 2).trim());
+          arr.push(obj);
+          stack.push({ obj, indent, _parentObj: arr, _parentKey: null });
+        }
+      } else if (entry._parentObj && entry._parentKey) {
+        // "- scalar" inside a sequence
+        const pk = entry._parentObj[entry._parentKey];
+        if (Array.isArray(pk)) {
+          pk.push(parseScalar(rest));
+        } else if (pk && typeof pk === 'object' && Object.keys(pk).length === 0) {
+          // Convert empty object to array (same rule as the mapping-in-sequence
+          // branch above) so plain block sequences like
+          //   active_guards:
+          //     - check_custom
+          // parse into arrays, not empty objects. Additive: previously valid
+          // YAML parses identically.
+          entry._parentObj[entry._parentKey] = [parseScalar(rest)];
+        }
+      }
+      continue;
+    }
+
+    // ── key: value pair ──
+    const kvMatch = trimmed.match(/^([^:]+):\s*(.*)$/);
+    if (kvMatch) {
+      const key = kvMatch[1].trim();
+      const val = kvMatch[2].trim();
+
+      if (val === '' || val === '|' || val === '>') {
+        // Empty value → children follow
+        if (!entry.obj[key]) entry.obj[key] = {};
+        stack.push({ obj: entry.obj[key], indent, _parentObj: entry.obj, _parentKey: key });
+      } else if (val.startsWith('[') && val.endsWith(']')) {
+        entry.obj[key] = val.slice(1, -1).split(',').map(s => parseScalar(s.trim()));
+      } else if (val.startsWith('{') && val.endsWith('}')) {
+        entry.obj[key] = parseFlowMapping(val);
+      } else {
+        entry.obj[key] = parseScalar(val);
+      }
+      continue;
+    }
+  }
+
+  return root;
+}
+
+function parseScalar(val) {
+  if (val === '' || val === '~' || val === 'null') return null;
+  if (val === 'true') return true;
+  if (val === 'false') return false;
+  if (/^-?\d+$/.test(val)) return parseInt(val, 10);
+  if (/^-?\d+\.\d+$/.test(val)) return parseFloat(val);
+  // Strip quotes and unescape common escape sequences
+  if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+    return val.slice(1, -1).replace(/\\(.)/g, '$1');
+  }
+  return val;
+}
+
+function parseFlowMapping(str) {
+  const inner = str.slice(1, -1).trim();
+  if (!inner) return {};
+  const obj = {};
+  const pairs = inner.split(',');
+  for (const pair of pairs) {
+    const colonIdx = pair.indexOf(':');
+    if (colonIdx === -1) continue;
+    const k = pair.slice(0, colonIdx).trim();
+    const v = pair.slice(colonIdx + 1).trim();
+    obj[k] = parseScalar(v);
+  }
+  return obj;
+}
+
+// ═══════════════════════════════════════════════════════════════════════
+// Glob-to-Regex Converter (~15 lines)
+// Handles: **, *, {a,b} alternation
+// ═══════════════════════════════════════════════════════════════════════
+
+function globToRegex(glob) {
+  let re = glob
+    .replace(/\./g, '\\.')           // escape dots
+    .replace(/\*\*\//g, '{{GLOBSTAR_SLASH}}') // protect **/ (zero or more segments + separator)
+    .replace(/\*\*/g, '{{GLOBSTAR}}') // protect trailing **
+    .replace(/\*/g, '[^/]*')          // single * = no slashes
+    .replace(/\{\{GLOBSTAR_SLASH\}\}/g, '(?:.+/)?') // **/ = optional path segments
+    .replace(/\{\{GLOBSTAR\}\}/g, '.*') // ** = anything
+    .replace(/\{([^}]+)\}/g, (_, alt) =>
+      `(${alt.split(',').join('|')})`);  // {a,b} alternation
+  return new RegExp('^' + re + '$');
+}
+
+module.exports = { parseYaml, globToRegex };

package/test/adapters/astro.test.js

@@ -0,0 +1,102 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+const { createTmpProject, teardown } = require('../helpers');
+
+describe('AstroAdapter', () => {
+  const AstroAdapter = require('../../src/adapters/astro');
+
+  describe('constructor', () => {
+    it('creates adapter with correct name and projectType', () => {
+      const adapter = new AstroAdapter();
+      assert.strictEqual(adapter.name, 'Astro Framework');
+      assert.strictEqual(adapter.projectType, 'frontend');
+      assert.strictEqual(adapter.testRunner, 'Vitest / Playwright');
+    });
+  });
+
+  describe('detect()', () => {
+    it('returns true when package.json has astro dependency', () => {
+      const dir = createTmpProject({
+        'package.json': JSON.stringify({ dependencies: { astro: '4.0.0' } }),
+      });
+      try {
+        const adapter = new AstroAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns true when astro.config.mjs exists', () => {
+      const dir = createTmpProject({
+        'astro.config.mjs': 'export default {}',
+        'package.json': JSON.stringify({ dependencies: {} }),
+      });
+      try {
+        const adapter = new AstroAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns true when astro.config.js exists', () => {
+      const dir = createTmpProject({
+        'astro.config.js': 'module.exports = {}',
+        'package.json': JSON.stringify({ dependencies: {} }),
+      });
+      try {
+        const adapter = new AstroAdapter();
+        assert.strictEqual(adapter.detect(dir), true);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when no package.json exists', () => {
+      const dir = createTmpProject({});
+      try {
+        const adapter = new AstroAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+
+    it('returns false when package.json has no astro and no config file', () => {
+      const dir = createTmpProject({
+        'package.json': JSON.stringify({ dependencies: { react: '18.0.0' } }),
+      });
+      try {
+        const adapter = new AstroAdapter();
+        assert.strictEqual(adapter.detect(dir), false);
+      } finally {
+        teardown(dir);
+      }
+    });
+  });
+
+  describe('getTools()', () => {
+    it('returns array of tool objects with required fields', () => {
+      const adapter = new AstroAdapter();
+      const tools = adapter.getTools();
+      assert.ok(Array.isArray(tools));
+      assert.ok(tools.length > 0);
+      for (const tool of tools) {
+        assert.ok(tool.name);
+        assert.ok(tool.language);
+        assert.ok(typeof tool.command === 'string');
+        assert.ok(tool.description);
+      }
+    });
+  });
+
+  describe('getSafeguards()', () => {
+    it('returns non-empty array of strings', () => {
+      const adapter = new AstroAdapter();
+      const guards = adapter.getSafeguards();
+      assert.ok(Array.isArray(guards));
+      assert.ok(guards.length >= 5);
+    });
+  });
+});