@paths.design/caws-cli 8.0.1 → 8.2.0

package/dist/commands/specs.js

@@ -164,9 +164,9 @@ async function createSpec(id, options = {}) {
         console.log(chalk.blue(`📝 Creating spec with new name: ${newId}`));
         return await createSpec(newId, { ...options, interactive: false });
       } else if (answer === 'merge') {
-        console.log(chalk.yellow('🔄 Merge functionality not yet implemented.'));
-        console.log(chalk.blue('💡 For now, consider creating with a different name.'));
-        return null;
+        // Merge new spec data with existing spec
+        console.log(chalk.blue('🔄 Merging with existing spec...'));
+        return await mergeSpec(id, options);
       } else if (answer === 'override') {
         console.log(chalk.yellow('⚠️  Overriding existing spec...'));
       }
@@ -385,6 +385,133 @@ async function updateSpec(id, updates = {}) {
   return true;
 }
 
+/**
+ * Merge new spec data with an existing spec
+ * Combines acceptance criteria, updates metadata, preserves history
+ * @param {string} id - Spec identifier
+ * @param {Object} options - Options including new spec data to merge
+ * @returns {Promise<Object>} Merged spec
+ */
+async function mergeSpec(id, options = {}) {
+  const existingSpec = await loadSpec(id);
+  if (!existingSpec) {
+    throw new Error(`Spec '${id}' not found`);
+  }
+
+  console.log(chalk.blue(`\n📋 Merging into existing spec: ${id}`));
+  console.log(chalk.gray('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  // Show existing spec summary
+  console.log(chalk.gray(`Existing spec:`));
+  console.log(chalk.gray(`   Title: ${existingSpec.title}`));
+  console.log(chalk.gray(`   Status: ${existingSpec.status}`));
+  console.log(
+    chalk.gray(`   Acceptance Criteria: ${existingSpec.acceptance_criteria?.length || 0}`)
+  );
+  console.log('');
+
+  // Prepare merge data from options
+  const {
+    title: newTitle,
+    description: newDescription,
+    acceptance_criteria: newCriteria,
+    mode: newMode,
+    risk_tier: newRiskTier,
+  } = options;
+
+  const mergedSpec = { ...existingSpec };
+
+  // Track what was merged
+  const mergeLog = [];
+
+  // Merge title (prefer new if provided)
+  if (newTitle && newTitle !== existingSpec.title) {
+    mergedSpec.title = newTitle;
+    mergeLog.push(`Title updated: "${existingSpec.title}" → "${newTitle}"`);
+  }
+
+  // Merge description
+  if (newDescription) {
+    if (existingSpec.description) {
+      mergedSpec.description = `${existingSpec.description}\n\n---\n\n${newDescription}`;
+      mergeLog.push('Description appended');
+    } else {
+      mergedSpec.description = newDescription;
+      mergeLog.push('Description added');
+    }
+  }
+
+  // Merge acceptance criteria (append new ones, avoid duplicates)
+  if (newCriteria && Array.isArray(newCriteria) && newCriteria.length > 0) {
+    const existingCriteria = existingSpec.acceptance_criteria || [];
+    const existingIds = new Set(existingCriteria.map((c) => c.id));
+
+    const criteriaToAdd = newCriteria.filter((c) => !existingIds.has(c.id));
+    if (criteriaToAdd.length > 0) {
+      mergedSpec.acceptance_criteria = [...existingCriteria, ...criteriaToAdd];
+      mergeLog.push(`Added ${criteriaToAdd.length} new acceptance criteria`);
+    }
+
+    // Also update the 'acceptance' array if it exists
+    if (existingSpec.acceptance) {
+      const existingAcceptIds = new Set(existingSpec.acceptance.map((a) => a.id));
+      const acceptToAdd = newCriteria.filter((c) => !existingAcceptIds.has(c.id));
+      if (acceptToAdd.length > 0) {
+        mergedSpec.acceptance = [...existingSpec.acceptance, ...acceptToAdd];
+      }
+    }
+  }
+
+  // Merge mode (prefer higher tier if both provided)
+  if (newMode && newMode !== existingSpec.mode) {
+    // Mode priority: crisis > standard > minimal
+    const modePriority = { minimal: 1, standard: 2, crisis: 3 };
+    if ((modePriority[newMode] || 0) > (modePriority[existingSpec.mode] || 0)) {
+      mergedSpec.mode = newMode;
+      mergeLog.push(`Mode upgraded: ${existingSpec.mode} → ${newMode}`);
+    }
+  }
+
+  // Merge risk tier (prefer higher risk if both provided)
+  if (newRiskTier && newRiskTier !== existingSpec.risk_tier) {
+    // Risk priority: T1 > T2 > T3
+    const riskPriority = { T3: 1, T2: 2, T1: 3, 3: 1, 2: 2, 1: 3 };
+    if ((riskPriority[newRiskTier] || 0) > (riskPriority[existingSpec.risk_tier] || 0)) {
+      mergedSpec.risk_tier = newRiskTier;
+      mergeLog.push(`Risk tier updated: ${existingSpec.risk_tier} → ${newRiskTier}`);
+    }
+  }
+
+  // Update metadata
+  mergedSpec.updated_at = new Date().toISOString();
+
+  // Add merge history entry
+  if (!mergedSpec.history) {
+    mergedSpec.history = [];
+  }
+  mergedSpec.history.push({
+    action: 'merge',
+    timestamp: new Date().toISOString(),
+    changes: mergeLog,
+  });
+
+  // Save merged spec
+  await updateSpec(id, mergedSpec);
+
+  // Display merge results
+  console.log(chalk.green('✅ Merge completed:'));
+  if (mergeLog.length > 0) {
+    mergeLog.forEach((change) => {
+      console.log(chalk.gray(`   • ${change}`));
+    });
+  } else {
+    console.log(chalk.gray('   • No changes needed (specs were identical)'));
+  }
+  console.log('');
+
+  return mergedSpec;
+}
+
 /**
  * Delete a spec file
  * @param {string} id - Spec identifier
@@ -544,9 +671,12 @@ async function migrateFromLegacy(options = {}, createSpecFn = createSpec) {
   let selectedFeatures = features;
 
   if (options.interactive) {
-    // For now, just use all suggested features
-    // In a full implementation, this would prompt for selection
-    console.log(chalk.blue('\n📋 Using all suggested features for migration'));
+    selectedFeatures = await selectFeaturesInteractively(features);
+    if (selectedFeatures.length === 0) {
+      console.log(chalk.yellow('⚠️  No features selected. Migration cancelled.'));
+      return { migrated: 0, total: features.length, createdSpecs: [], legacySpec: legacySpec.id };
+    }
+    console.log(chalk.blue(`\n📋 Migrating ${selectedFeatures.length} selected features`));
   }
 
   if (options.features && options.features.length > 0) {
@@ -614,6 +744,54 @@ async function migrateFromLegacy(options = {}, createSpecFn = createSpec) {
   };
 }
 
+/**
+ * Interactive feature selection for migration
+ * @param {Array} features - Array of suggested features
+ * @returns {Promise<Array>} Selected features
+ */
+async function selectFeaturesInteractively(features) {
+  const readline = require('readline');
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  console.log(chalk.cyan('\n📋 Select features to migrate:\n'));
+  features.forEach((f, i) => {
+    const scope = f.scope?.in?.join(', ') || 'N/A';
+    console.log(`  ${chalk.yellow(i + 1)}. ${chalk.bold(f.id || f.name)} - ${f.title || f.description}`);
+    console.log(chalk.gray(`     Scope: ${scope}`));
+  });
+  console.log(chalk.cyan(`\nEnter numbers separated by commas, or 'all' for all features:`));
+  console.log(chalk.gray(`Example: 1,3,5 or all`));
+
+  try {
+    const answer = await question(rl, '> ');
+    const trimmed = answer.trim().toLowerCase();
+
+    if (trimmed === 'all' || trimmed === '*') {
+      return features;
+    }
+
+    if (trimmed === '' || trimmed === 'none' || trimmed === 'q' || trimmed === 'quit') {
+      return [];
+    }
+
+    // Parse comma-separated numbers
+    const indices = trimmed
+      .split(',')
+      .map(n => parseInt(n.trim(), 10) - 1)
+      .filter(i => !isNaN(i) && i >= 0 && i < features.length);
+
+    // Remove duplicates and sort
+    const uniqueIndices = [...new Set(indices)].sort((a, b) => a - b);
+
+    return features.filter((_, i) => uniqueIndices.includes(i));
+  } finally {
+    await closeReadline(rl);
+  }
+}
+
 /**
  * Ask user how to resolve spec creation conflicts
  * @returns {Promise<string>} User's choice: 'cancel', 'rename', 'merge', 'override'

package/dist/commands/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.js"],"names":[],"mappings":"AA8uBA;;;GAGG;AACH,2DA+IC;AAp3BD;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAahC;AAgBD;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CAgC3B;AAED;;;GAGG;AACH,uCAFa,OAAO,KAAQ,CA+B3B;AAED;;;GAGG;AACH,oCAFa,OAAO,KAAQ,CA0D3B;AAED;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAS3B;AAwBD;;;GAGG;AACH,+CAgGC;AAED;;;;;GAKG;AACH,4DAHW,MAAM,GACJ,MAAM,EAAE,CAoCpB"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/commands/status.js"],"names":[],"mappings":"AA02BA;;;GAGG;AACH,2DA+IC;AA/+BD;;;;GAIG;AACH,2CAHW,MAAM,GACJ,OAAO,CAAC,MAAO,IAAI,CAAC,CAahC;AAgBD;;;GAGG;AACH,iCAFa,OAAO,KAAQ,CAgC3B;AAED;;;GAGG;AACH,uCAFa,OAAO,KAAQ,CA+B3B;AAED;;;GAGG;AACH,oCAFa,OAAO,KAAQ,CA0D3B;AAED;;;GAGG;AACH,qCAFa,OAAO,KAAQ,CAO3B;AA8HD;;;GAGG;AACH,+CAgGC;AAED;;;;;GAKG;AACH,4DAHW,MAAM,GACJ,MAAM,EAAE,CAoCpB"}

package/dist/commands/status.js

@@ -8,6 +8,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
+// child_process removed - execSync no longer used directly
 const { safeAsync, outputResult } = require('../error-handler');
 const { parallel } = require('../utils/async-utils');
 
@@ -181,14 +182,114 @@ async function loadWaiverStatus() {
  * @returns {Promise<Object>} Quality gates status
  */
 async function checkQualityGates() {
-  // For now, return a placeholder
-  // Quality gates are available via CLI or MCP
   return {
     checked: false,
     message: 'Run: caws quality-gates or use MCP tool caws_quality_gates_run for full gate status',
   };
 }
 
+/**
+ * Get test coverage from coverage reports
+ * Looks for common coverage report locations and formats
+ * @returns {Promise<Object>} Coverage data with percentage and details
+ */
+async function getTestCoverage() {
+  const coverageLocations = [
+    // Jest/Istanbul coverage
+    { path: 'coverage/coverage-summary.json', type: 'istanbul' },
+    { path: 'coverage/lcov-report/index.html', type: 'lcov-html' },
+    { path: 'coverage/coverage-final.json', type: 'istanbul-final' },
+    // NYC coverage
+    { path: '.nyc_output/coverage-summary.json', type: 'nyc' },
+    // C8 coverage
+    { path: 'coverage/c8/coverage-summary.json', type: 'c8' },
+  ];
+
+  try {
+    for (const loc of coverageLocations) {
+      const coveragePath = path.join(process.cwd(), loc.path);
+      if (await fs.pathExists(coveragePath)) {
+        if (loc.type === 'istanbul' || loc.type === 'nyc' || loc.type === 'c8') {
+          const content = await fs.readFile(coveragePath, 'utf8');
+          const data = JSON.parse(content);
+
+          // Istanbul/NYC format has a "total" key with coverage percentages
+          if (data.total) {
+            const lines = data.total.lines?.pct || 0;
+            const statements = data.total.statements?.pct || 0;
+            const branches = data.total.branches?.pct || 0;
+            const functions = data.total.functions?.pct || 0;
+
+            return {
+              available: true,
+              percentage: Math.round((lines + statements + branches + functions) / 4),
+              lines: Math.round(lines),
+              statements: Math.round(statements),
+              branches: Math.round(branches),
+              functions: Math.round(functions),
+              source: loc.path,
+            };
+          }
+        } else if (loc.type === 'istanbul-final') {
+          // coverage-final.json has per-file data, need to aggregate
+          const content = await fs.readFile(coveragePath, 'utf8');
+          const data = JSON.parse(content);
+
+          let totalStatements = 0;
+          let coveredStatements = 0;
+
+          for (const file of Object.values(data)) {
+            const s = file.s || {};
+            for (const count of Object.values(s)) {
+              totalStatements++;
+              if (count > 0) coveredStatements++;
+            }
+          }
+
+          if (totalStatements > 0) {
+            const percentage = Math.round((coveredStatements / totalStatements) * 100);
+            return {
+              available: true,
+              percentage,
+              source: loc.path,
+            };
+          }
+        }
+      }
+    }
+
+    // Try running test coverage command if no reports found
+    try {
+      // Check if package.json has a coverage script
+      const pkgPath = path.join(process.cwd(), 'package.json');
+      if (await fs.pathExists(pkgPath)) {
+        const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+        if (pkg.scripts && (pkg.scripts.coverage || pkg.scripts['test:coverage'])) {
+          return {
+            available: false,
+            percentage: null,
+            message: 'Run npm run coverage to generate coverage report',
+          };
+        }
+      }
+    } catch {
+      // Ignore package.json errors
+    }
+
+    return {
+      available: false,
+      percentage: null,
+      message: 'No coverage report found',
+    };
+  } catch (error) {
+    return {
+      available: false,
+      percentage: null,
+      message: `Error reading coverage: ${error.message}`,
+    };
+  }
+}
+
 /**
  * Get time since last update
  * @param {string} timestamp - ISO timestamp
@@ -388,7 +489,7 @@ function getProgressColor(percentage) {
  * @param {Object} data - Status data
  * @param {string} currentMode - Current CAWS mode
  */
-function displayVisualStatus(data, currentMode) {
+async function displayVisualStatus(data, currentMode) {
   const { spec, specs, hooks, provenance, waivers, gates } = data;
   const modes = require('../config/modes');
   const tierConfig = modes.getTier(currentMode);
@@ -497,12 +598,35 @@ function displayVisualStatus(data, currentMode) {
       );
     }
 
-    // Test Coverage (placeholder for now)
-    console.log(
-      chalk.gray(
-        `   Test Coverage: ${chalk.blue('Calculating...')} ${createProgressBar(0, 100)} 0%`
-      )
-    );
+    // Test Coverage
+    const coverage = await getTestCoverage();
+    if (coverage.available && coverage.percentage !== null) {
+      const coverageColor =
+        coverage.percentage >= 80
+          ? chalk.green
+          : coverage.percentage >= 50
+            ? chalk.yellow
+            : chalk.red;
+      const coverageBar = createProgressBar(coverage.percentage, 100);
+      console.log(
+        chalk.gray(
+          `   Test Coverage: ${coverageColor(`${coverage.percentage}%`)} ${coverageBar}`
+        )
+      );
+      if (coverage.lines !== undefined) {
+        console.log(
+          chalk.gray(
+            `                  Lines: ${coverage.lines}% | Branches: ${coverage.branches}% | Functions: ${coverage.functions}%`
+          )
+        );
+      }
+    } else {
+      console.log(
+        chalk.gray(
+          `   Test Coverage: ${chalk.yellow('N/A')} ${createProgressBar(0, 100)} ${chalk.gray(coverage.message || 'No report')}`
+        )
+      );
+    }
 
     // Risk Tier Indicator
     const riskColor =
@@ -839,7 +963,7 @@ async function statusCommand(options = {}) {
           console.log(JSON.stringify(result, null, 2));
         } else {
           // Visual output
-          displayVisualStatus(
+          await displayVisualStatus(
             {
               spec,
               specs,

package/dist/commands/templates.js

@@ -149,7 +149,7 @@ function listTemplates() {
   const totalTemplates = Object.keys(templates).length;
 
   if (totalAvailable < totalTemplates) {
-    console.log(chalk.yellow(`\n⏳ ${totalTemplates - totalAvailable} templates coming soon`));
+    console.log(chalk.yellow(`\n⏳ ${totalTemplates - totalAvailable} additional templates in development`));
   }
 
   console.log(chalk.blue('\n📚 Learn more:'));
@@ -181,7 +181,7 @@ function showTemplateInfo(templateId) {
   console.log(chalk.white(`Risk Tier: ${template.tier}`));
   console.log(
     chalk.white(
-      `Status: ${template.available ? chalk.green('Available') : chalk.yellow('Coming Soon')}`
+      `Status: ${template.available ? chalk.green('Available') : chalk.yellow('In Development')}`
     )
   );
 

package/dist/commands/worktree.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Handle worktree subcommands
+ * @param {string} subcommand - Subcommand name
+ * @param {Object} options - Command options
+ */
+export function worktreeCommand(subcommand: string, options?: any): Promise<void>;
+//# sourceMappingURL=worktree.d.ts.map

package/dist/commands/worktree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worktree.d.ts","sourceRoot":"","sources":["../../src/commands/worktree.js"],"names":[],"mappings":"AAcA;;;;GAIG;AACH,4CAHW,MAAM,gCAuBhB"}

package/dist/commands/worktree.js

@@ -0,0 +1,136 @@
+/**
+ * @fileoverview CAWS Worktree CLI Command
+ * Manages git worktrees for agent scope isolation
+ * @author @darianrosebrook
+ */
+
+const chalk = require('chalk');
+const {
+  createWorktree,
+  listWorktrees,
+  destroyWorktree,
+  pruneWorktrees,
+} = require('../worktree/worktree-manager');
+
+/**
+ * Handle worktree subcommands
+ * @param {string} subcommand - Subcommand name
+ * @param {Object} options - Command options
+ */
+async function worktreeCommand(subcommand, options = {}) {
+  try {
+    switch (subcommand) {
+      case 'create':
+        return handleCreate(options);
+      case 'list':
+        return handleList();
+      case 'destroy':
+        return handleDestroy(options);
+      case 'prune':
+        return handlePrune(options);
+      default:
+        console.error(chalk.red(`Unknown worktree subcommand: ${subcommand}`));
+        console.log(chalk.blue('Available: create, list, destroy, prune'));
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(chalk.red(`❌ ${error.message}`));
+    process.exit(1);
+  }
+}
+
+function handleCreate(options) {
+  const { name, scope, baseBranch, specId } = options;
+
+  if (!name) {
+    console.error(chalk.red('❌ Worktree name is required'));
+    console.log(chalk.blue('Usage: caws worktree create <name> [--scope "src/auth/**"]'));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`🌿 Creating worktree: ${name}`));
+
+  const entry = createWorktree(name, { scope, baseBranch, specId });
+
+  console.log(chalk.green(`✅ Worktree created`));
+  console.log(chalk.gray(`   Path:   ${entry.path}`));
+  console.log(chalk.gray(`   Branch: ${entry.branch}`));
+  if (entry.scope) console.log(chalk.gray(`   Scope:  ${entry.scope}`));
+  if (entry.specId) console.log(chalk.gray(`   Spec:   ${entry.specId}`));
+  console.log(chalk.blue(`\n💡 cd ${entry.path} to start working in the isolated worktree`));
+}
+
+function handleList() {
+  const entries = listWorktrees();
+
+  if (entries.length === 0) {
+    console.log(chalk.gray('No worktrees registered.'));
+    console.log(chalk.blue('Create one with: caws worktree create <name>'));
+    return;
+  }
+
+  console.log(chalk.bold.cyan('🌿 CAWS Worktrees'));
+  console.log(chalk.cyan('━'.repeat(70)));
+  console.log(
+    chalk.bold(
+      'Name'.padEnd(20) +
+        'Status'.padEnd(12) +
+        'Branch'.padEnd(20) +
+        'Scope'
+    )
+  );
+  console.log(chalk.gray('─'.repeat(70)));
+
+  for (const entry of entries) {
+    const statusColor =
+      entry.status === 'active'
+        ? chalk.green
+        : entry.status === 'destroyed'
+        ? chalk.gray
+        : chalk.yellow;
+
+    console.log(
+      entry.name.padEnd(20) +
+        statusColor(entry.status.padEnd(12)) +
+        (entry.branch || '').padEnd(20) +
+        (entry.scope || '-')
+    );
+  }
+
+  console.log('');
+}
+
+function handleDestroy(options) {
+  const { name, deleteBranch, force } = options;
+
+  if (!name) {
+    console.error(chalk.red('❌ Worktree name is required'));
+    console.log(chalk.blue('Usage: caws worktree destroy <name> [--delete-branch] [--force]'));
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`🗑️  Destroying worktree: ${name}`));
+  destroyWorktree(name, { deleteBranch, force });
+  console.log(chalk.green(`✅ Worktree '${name}' destroyed`));
+  if (deleteBranch) {
+    console.log(chalk.gray('   Branch also deleted'));
+  }
+}
+
+function handlePrune(options) {
+  const maxAge = options.maxAge !== undefined ? parseInt(options.maxAge, 10) : 30;
+
+  console.log(chalk.cyan(`🧹 Pruning worktrees (max age: ${maxAge} days)`));
+  const pruned = pruneWorktrees({ maxAgeDays: maxAge });
+
+  if (pruned.length === 0) {
+    console.log(chalk.gray('Nothing to prune.'));
+  } else {
+    console.log(chalk.green(`✅ Pruned ${pruned.length} worktree(s):`));
+    for (const entry of pruned) {
+      console.log(chalk.gray(`   - ${entry.name} (created ${entry.createdAt})`));
+    }
+  }
+}
+
+module.exports = { worktreeCommand };

package/dist/config/lite-scope.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Load lite scope configuration from .caws/scope.json
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {Object} Scope configuration (defaults if file not found)
+ */
+export function loadLiteScope(projectRoot?: string): any;
+/**
+ * Check if a file path is allowed by the scope configuration
+ * @param {string} filePath - Relative file path to check
+ * @param {Object} [scope] - Scope configuration (loads from disk if not provided)
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {boolean} Whether the path is allowed
+ */
+export function isPathAllowed(filePath: string, scope?: any, projectRoot?: string): boolean;
+/**
+ * Check if a filename or path matches any banned pattern
+ * @param {string} filePath - File path to check
+ * @param {Object} [scope] - Scope configuration (loads from disk if not provided)
+ * @param {string} [projectRoot] - Project root directory
+ * @returns {{ matched: boolean, pattern: string|null, category: string|null }} Match result
+ */
+export function matchesBannedPattern(filePath: string, scope?: any, projectRoot?: string): {
+    matched: boolean;
+    pattern: string | null;
+    category: string | null;
+};
+/**
+ * Default scope configuration for lite mode
+ * @returns {Object} Default scope.json contents
+ */
+export function getLiteScopeDefaults(): any;
+export const SCOPE_FILE: ".caws/scope.json";
+//# sourceMappingURL=lite-scope.d.ts.map

package/dist/config/lite-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lite-scope.d.ts","sourceRoot":"","sources":["../../src/config/lite-scope.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,4CAHW,MAAM,OAgChB;AAED;;;;;;GAMG;AACH,wCALW,MAAM,6BAEN,MAAM,GACJ,OAAO,CAiCnB;AAED;;;;;;GAMG;AACH,+CALW,MAAM,6BAEN,MAAM,GACJ;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAsC7E;AAzID;;;GAGG;AACH,4CAYC;AAlBD,yBAAmB,kBAAkB,CAAC"}