@pimzino/sgrep 1.3.0

package/build/plugins/sgrep/hooks/sgrep_enhance.js

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const os = require("os");
+
+const DEBUG_ENABLED = process.env.SGREP_DEBUG === "1" || process.env.SGREP_DEBUG === "true";
+const DEBUG_LOG_FILE = process.env.SGREP_ENHANCE_LOG || path.join(os.tmpdir(), "sgrep-enhance.log");
+
+function debugLog(message) {
+  if (!DEBUG_ENABLED) return;
+  try {
+    const dir = path.dirname(DEBUG_LOG_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const stamp = new Date().toISOString();
+    fs.appendFileSync(DEBUG_LOG_FILE, `[${stamp}] ${message}\n`);
+  } catch (e) {
+    // Ignore errors
+  }
+}
+
+function debugLogSection(title, content) {
+  debugLog(`\n========== ${title} ==========`);
+  debugLog(content);
+  debugLog(`========== END ${title} ==========\n`);
+}
+
+function readHookInput() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      if (!data.trim()) {
+        debugLog("No input data received from stdin");
+        resolve(null);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(data);
+        debugLogSection("RAW HOOK INPUT", JSON.stringify(parsed, null, 2));
+        resolve(parsed);
+      } catch (e) {
+        debugLog(`Failed to decode JSON: ${e.message}`);
+        debugLog(`Raw data: ${data}`);
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * Determine if enhancement should proceed.
+ * Auto-confirms on all platforms (no user prompting).
+ */
+function shouldEnhance(prompt) {
+  debugLog("Auto-confirming enhancement (prompting disabled on all platforms)");
+  return true;
+}
+
+async function main() {
+  debugLog("\n\n====================================================");
+  debugLog("SGREP ENHANCE HOOK TRIGGERED - UserPromptSubmit");
+  debugLog("====================================================");
+
+  const payload = await readHookInput();
+  if (!payload) {
+    debugLog("ERROR: No payload received - exiting");
+    process.exit(0);
+  }
+
+  // Log all payload fields
+  debugLog(`Hook Event: ${payload.hook_event_name || 'unknown'}`);
+  debugLog(`Session ID: ${payload.session_id || 'unknown'}`);
+  debugLog(`CWD: ${payload.cwd || 'unknown'}`);
+  debugLog(`Permission Mode: ${payload.permission_mode || 'unknown'}`);
+
+  const prompt = payload.prompt || "";
+  debugLogSection("ORIGINAL PROMPT", prompt);
+
+  // Skip enhancement for very short prompts or commands
+  if (prompt.length < 10) {
+    debugLog("SKIP: Prompt too short (< 10 chars)");
+    process.exit(0);
+  }
+  if (prompt.startsWith("/")) {
+    debugLog("SKIP: Prompt is a slash command");
+    process.exit(0);
+  }
+
+  // Check if enhancement should proceed (auto-confirms on all platforms)
+  debugLog("Checking if enhancement should proceed...");
+  const shouldProceed = shouldEnhance(prompt);
+  debugLog(`Enhancement decision: ${shouldProceed ? 'proceeding' : 'skipped'}`);
+
+  if (!shouldProceed) {
+    debugLog("SKIP: Enhancement not proceeding");
+    process.exit(0);
+  }
+
+  try {
+    // Call sgrep enhance with JSON output
+    debugLog("Calling: sgrep enhance --json \"<prompt>\"");
+
+    // Escape the prompt for shell
+    const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\n/g, ' ');
+
+    const result = execSync(`sgrep enhance --json "${escapedPrompt}"`, {
+      encoding: "utf8",
+      timeout: 60000, // 60 second timeout
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    debugLogSection("SGREP ENHANCE RAW RESULT", result);
+
+    // Parse the JSON result
+    const parsed = JSON.parse(result);
+    const enhanced = parsed.enhanced || null;
+
+    if (!enhanced) {
+      debugLog("SKIP: No enhanced prompt in result");
+      process.exit(0);
+    }
+
+    if (enhanced === prompt) {
+      debugLog("SKIP: Enhanced prompt same as original");
+      process.exit(0);
+    }
+
+    debugLogSection("ENHANCED PROMPT", enhanced);
+
+    // Output JSON with additionalContext - this adds context to Claude
+    const response = {
+      hookSpecificOutput: {
+        hookEventName: "UserPromptSubmit",
+        additionalContext: `[sgrep enhanced context]\n${enhanced}`
+      }
+    };
+
+    debugLogSection("HOOK RESPONSE", JSON.stringify(response, null, 2));
+    console.log(JSON.stringify(response));
+    debugLog("SUCCESS: Enhancement complete");
+  } catch (e) {
+    debugLog(`ERROR: Enhancement failed - ${e.message}`);
+    if (e.stderr) {
+      debugLog(`STDERR: ${e.stderr}`);
+    }
+    // On any error, just continue without enhancement
+  }
+
+  debugLog("====================================================\n");
+  process.exit(0);
+}
+
+main();

package/build/plugins/sgrep/hooks/sgrep_watch.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const { spawn, execSync } = require("child_process");
+const os = require("os");
+
+const DEBUG_ENABLED = process.env.SGREP_DEBUG === "1" || process.env.SGREP_DEBUG === "true";
+const DEBUG_LOG_FILE = process.env.SGREP_WATCH_LOG || path.join(os.tmpdir(), "sgrep-watch.log");
+
+function debugLog(message) {
+  if (!DEBUG_ENABLED) return;
+  try {
+    const dir = path.dirname(DEBUG_LOG_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const stamp = new Date().toISOString();
+    fs.appendFileSync(DEBUG_LOG_FILE, `[${stamp}] ${message}\n`);
+  } catch (e) {
+    // Ignore errors
+  }
+}
+
+function debugLogSection(title, content) {
+  debugLog(`\n========== ${title} ==========`);
+  debugLog(content);
+  debugLog(`========== END ${title} ==========\n`);
+}
+
+function readHookInput() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      if (!data.trim()) {
+        debugLog("No input data received from stdin");
+        resolve(null);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(data);
+        debugLogSection("RAW HOOK INPUT", JSON.stringify(parsed, null, 2));
+        resolve(parsed);
+      } catch (e) {
+        debugLog(`Failed to decode JSON: ${e.message}`);
+        debugLog(`Raw data: ${data}`);
+        resolve(null);
+      }
+    });
+  });
+}
+
+async function main() {
+  debugLog("\n\n====================================================");
+  debugLog("SGREP WATCH HOOK TRIGGERED - SessionStart");
+  debugLog("====================================================");
+
+  const payload = await readHookInput();
+  if (!payload) {
+    debugLog("ERROR: No payload received - exiting with error");
+    process.exit(1);
+  }
+
+  // Log all payload fields for debugging
+  debugLog(`Hook Event: ${payload.hook_event_name || 'unknown'}`);
+  debugLog(`Session ID: ${payload.session_id || 'unknown'}`);
+  debugLog(`Source: ${payload.source || 'unknown'} (startup/resume/clear/compact)`);
+  debugLog(`CWD: ${payload.cwd || 'unknown'}`);
+  debugLog(`Permission Mode: ${payload.permission_mode || 'unknown'}`);
+  debugLog(`Transcript Path: ${payload.transcript_path || 'unknown'}`);
+  debugLog(`Model: ${payload.model || 'unknown'}`);
+  if (payload.agent_type) {
+    debugLog(`Agent Type: ${payload.agent_type}`);
+  }
+
+  const sessionId = payload.session_id || "default";
+  const pidFile = path.join(os.tmpdir(), `sgrep-watch-pid-${sessionId}.txt`);
+  const logFile = path.join(os.tmpdir(), `sgrep-watch-command-${sessionId}.log`);
+
+  debugLog(`PID file path: ${pidFile}`);
+  debugLog(`Log file path: ${logFile}`);
+
+  if (fs.existsSync(pidFile)) {
+    const existingPid = fs.readFileSync(pidFile, "utf8").trim();
+    debugLog(`SKIP: PID file already exists with PID: ${existingPid}`);
+    // Check if process is still running
+    if (existingPid && existingPid !== "0") {
+      try {
+        process.kill(parseInt(existingPid, 10), 0); // Signal 0 = check if process exists
+        debugLog(`Process ${existingPid} is still running`);
+      } catch (e) {
+        debugLog(`Process ${existingPid} is not running, will restart`);
+        fs.unlinkSync(pidFile);
+        // Fall through to start new process
+      }
+    }
+    if (fs.existsSync(pidFile)) {
+      // Still exists, so process is running
+      const response = {
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: "The sgrep semantic search tool is available. Use `sgrep \"query\"` for semantic code search, `sgrep ask \"question\"` for explanations, and `sgrep enhance \"prompt\"` to improve vague prompts.",
+        },
+      };
+      console.log(JSON.stringify(response));
+      process.exit(0);
+    }
+  }
+
+  // Start sgrep watch as a detached process
+  debugLog("Starting sgrep watch process...");
+
+  // Check if sgrep is available
+  let sgrepPath = "sgrep";
+  const isWindows = process.platform === "win32";
+
+  try {
+    // On Windows, we need to find sgrep.cmd specifically
+    const whichCmd = isWindows ? "where sgrep.cmd" : "which sgrep";
+    const whichResult = execSync(whichCmd, {
+      encoding: "utf8",
+      timeout: 5000,
+    }).trim().split(/\r?\n/)[0];
+    sgrepPath = whichResult;
+    debugLog(`Found sgrep at: ${sgrepPath}`);
+  } catch (e) {
+    debugLog(`Could not find sgrep.cmd, trying 'where sgrep'...`);
+    // Fallback to finding sgrep without extension
+    try {
+      const whichResult = execSync(isWindows ? "where sgrep" : "which sgrep", {
+        encoding: "utf8",
+        timeout: 5000,
+      }).trim().split(/\r?\n/)[0];
+
+      // On Windows, if we got a path without extension, add .cmd
+      if (isWindows && !whichResult.toLowerCase().endsWith(".cmd") && !whichResult.toLowerCase().endsWith(".exe")) {
+        sgrepPath = whichResult + ".cmd";
+        debugLog(`Found sgrep at: ${whichResult}, using: ${sgrepPath}`);
+      } else {
+        sgrepPath = whichResult;
+        debugLog(`Found sgrep at: ${sgrepPath}`);
+      }
+    } catch (e2) {
+      debugLog(`WARNING: Could not find sgrep in PATH, using 'sgrep' directly`);
+    }
+  }
+
+  try {
+    const out = fs.openSync(logFile, "w");
+    const isWindows = process.platform === "win32";
+
+    // Use --pid-file option to have sgrep write its own PID
+    // This gives us the actual Node.js process PID, not the cmd.exe wrapper
+    const args = ["watch", "--pid-file", pidFile];
+    debugLog(`Spawning: ${sgrepPath} ${args.join(" ")}`);
+
+    let child;
+    if (isWindows) {
+      // On Windows, we need to handle .cmd/.bat scripts differently
+      const isCmdScript = sgrepPath.toLowerCase().endsWith(".cmd") ||
+                          sgrepPath.toLowerCase().endsWith(".bat");
+
+      if (isCmdScript) {
+        debugLog(`sgrep is a batch script: ${sgrepPath}`);
+        child = spawn("cmd.exe", ["/c", sgrepPath, ...args], {
+          detached: true,
+          stdio: ["ignore", out, out],
+          windowsHide: true,
+        });
+      } else {
+        child = spawn(sgrepPath, args, {
+          detached: true,
+          stdio: ["ignore", out, out],
+          windowsHide: true,
+        });
+      }
+    } else {
+      child = spawn(sgrepPath, args, {
+        detached: true,
+        stdio: ["ignore", out, out],
+      });
+    }
+
+    debugLog(`Spawn returned wrapper PID: ${child.pid}`);
+
+    // Handle any spawn errors
+    child.on("error", (err) => {
+      debugLog(`Spawn error event: ${err.message}`);
+    });
+
+    // Unref so this script can exit
+    child.unref();
+
+    // Wait a moment for sgrep to write its PID file
+    debugLog("Waiting for sgrep to write its PID...");
+    let actualPid = null;
+    for (let i = 0; i < 20; i++) { // Wait up to 2 seconds
+      await new Promise(resolve => setTimeout(resolve, 100));
+      if (fs.existsSync(pidFile)) {
+        const content = fs.readFileSync(pidFile, "utf8").trim();
+        if (content && content !== "0") {
+          actualPid = content;
+          break;
+        }
+      }
+    }
+
+    if (actualPid) {
+      debugLog(`SUCCESS: sgrep watch started with PID: ${actualPid}`);
+    } else {
+      debugLog(`WARNING: sgrep watch may not have started properly - no PID file found`);
+    }
+
+    // Log the command output file location
+    debugLog(`sgrep watch output will be logged to: ${logFile}`);
+  } catch (e) {
+    debugLog(`ERROR: Failed to start sgrep watch - ${e.message}`);
+    if (e.stack) {
+      debugLog(`Stack: ${e.stack}`);
+    }
+  }
+
+  const response = {
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: "The sgrep semantic search tool is available. Use `sgrep \"query\"` for semantic code search, `sgrep ask \"question\"` for explanations, and `sgrep enhance \"prompt\"` to improve vague prompts.",
+    },
+  };
+
+  debugLogSection("HOOK RESPONSE", JSON.stringify(response, null, 2));
+  console.log(JSON.stringify(response));
+  debugLog("====================================================\n");
+  process.exit(0);
+}
+
+main();

package/build/plugins/sgrep/hooks/sgrep_watch_kill.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync } = require("child_process");
+
+const DEBUG_ENABLED = process.env.SGREP_DEBUG === "1" || process.env.SGREP_DEBUG === "true";
+const DEBUG_LOG_FILE = process.env.SGREP_WATCH_KILL_LOG || path.join(os.tmpdir(), "sgrep-watch-kill.log");
+
+function debugLog(message) {
+  if (!DEBUG_ENABLED) return;
+  try {
+    const dir = path.dirname(DEBUG_LOG_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const stamp = new Date().toISOString();
+    fs.appendFileSync(DEBUG_LOG_FILE, `[${stamp}] ${message}\n`);
+  } catch (e) {
+    // Ignore errors
+  }
+}
+
+function debugLogSection(title, content) {
+  debugLog(`\n========== ${title} ==========`);
+  debugLog(content);
+  debugLog(`========== END ${title} ==========\n`);
+}
+
+/**
+ * Kill a process by PID, with platform-specific handling
+ */
+function killProcess(pid) {
+  debugLog(`Attempting to kill process with PID: ${pid}`);
+
+  // First try Node.js process.kill
+  try {
+    process.kill(pid, "SIGTERM");
+    debugLog(`SUCCESS: Sent SIGTERM to process ${pid}`);
+    return true;
+  } catch (e) {
+    if (e.code === "ESRCH") {
+      debugLog(`INFO: Process ${pid} already exited`);
+      return true; // Consider success if already gone
+    }
+    debugLog(`process.kill failed: ${e.message} (code: ${e.code})`);
+  }
+
+  // On Windows, try taskkill as fallback
+  if (process.platform === "win32") {
+    try {
+      execSync(`taskkill /PID ${pid} /F`, {
+        encoding: "utf8",
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+      debugLog(`SUCCESS: Killed process ${pid} using taskkill`);
+      return true;
+    } catch (e) {
+      debugLog(`taskkill failed: ${e.message}`);
+    }
+  }
+
+  return false;
+}
+
+function readHookInput() {
+  return new Promise((resolve) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      if (!data.trim()) {
+        debugLog("No input data received from stdin");
+        resolve(null);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(data);
+        debugLogSection("RAW HOOK INPUT", JSON.stringify(parsed, null, 2));
+        resolve(parsed);
+      } catch (e) {
+        debugLog(`Failed to decode JSON: ${e.message}`);
+        debugLog(`Raw data: ${data}`);
+        resolve(null);
+      }
+    });
+  });
+}
+
+async function main() {
+  debugLog("\n\n====================================================");
+  debugLog("SGREP WATCH KILL HOOK TRIGGERED - SessionEnd");
+  debugLog("====================================================");
+
+  const payload = await readHookInput();
+  if (!payload) {
+    debugLog("ERROR: No payload received - exiting with error");
+    process.exit(1);
+  }
+
+  // Log all payload fields for debugging
+  debugLog(`Hook Event: ${payload.hook_event_name || 'unknown'}`);
+  debugLog(`Session ID: ${payload.session_id || 'unknown'}`);
+  debugLog(`Reason: ${payload.reason || 'unknown'} (clear/logout/prompt_input_exit/other)`);
+  debugLog(`CWD: ${payload.cwd || 'unknown'}`);
+  debugLog(`Permission Mode: ${payload.permission_mode || 'unknown'}`);
+  debugLog(`Transcript Path: ${payload.transcript_path || 'unknown'}`);
+
+  const sessionId = payload.session_id || "default";
+  const pidFile = path.join(os.tmpdir(), `sgrep-watch-pid-${sessionId}.txt`);
+
+  debugLog(`Looking for PID file: ${pidFile}`);
+
+  if (!fs.existsSync(pidFile)) {
+    debugLog(`SKIP: PID file not found - sgrep watch may not have been started`);
+    process.exit(0); // Not an error - process may not have been started
+  }
+
+  let killed = false;
+
+  try {
+    const pidContent = fs.readFileSync(pidFile, "utf8").trim();
+    debugLog(`PID file content: "${pidContent}"`);
+
+    const pid = parseInt(pidContent, 10);
+    debugLog(`Parsed PID: ${pid}`);
+
+    if (!isNaN(pid) && pid > 0) {
+      killed = killProcess(pid);
+    } else {
+      debugLog(`WARNING: Invalid PID (${pid}), cannot kill process`);
+    }
+  } catch (e) {
+    debugLog(`ERROR reading PID file: ${e.message}`);
+  }
+
+  // Clean up PID file (sgrep watch should also clean it up on exit, but be safe)
+  try {
+    if (fs.existsSync(pidFile)) {
+      fs.unlinkSync(pidFile);
+      debugLog(`SUCCESS: Removed PID file: ${pidFile}`);
+    }
+  } catch (cleanupErr) {
+    debugLog(`Failed to clean up PID file: ${cleanupErr.message}`);
+  }
+
+  debugLog(`Kill operation completed. Success: ${killed}`);
+
+
+  debugLog("====================================================\n");
+  process.exit(0);
+}
+
+main();

package/build/plugins/sgrep/skills/sgrep/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: sgrep
+description: "Semantic grep - search codebases by meaning using AI. Use this skill when you need to search for code by functionality, understand codebase architecture, or enhance prompts with codebase context. Replaces pattern-based grep with natural language understanding."
+---
+
+## Overview
+
+sgrep (semantic grep) is a powerful CLI tool that uses AI to search codebases by meaning rather than exact text patterns. It understands what code does, not just what it's named.
+
+## CRITICAL: How to Run sgrep
+
+**ALWAYS run sgrep from the project root directory. NEVER use `cd` before running sgrep.**
+
+sgrep automatically searches the entire codebase from your current working directory. Using `cd` to navigate into subdirectories before running sgrep will limit your search scope and miss relevant code.
+
+```bash
+# CORRECT - run from project root
+sgrep "authentication middleware"
+sgrep ask "how does routing work?"
+
+# WRONG - do NOT cd into subdirectories
+cd src/frontend && sgrep "routing"  # BAD: limits search scope
+cd api && sgrep "authentication"    # BAD: misses related code elsewhere
+```
+
+## When to Use This Skill
+
+Invoke this skill when:
+
+- User asks to search for code by functionality (e.g., "find authentication code")
+- User wants to understand how something works in the codebase
+- User needs to find related files across the codebase
+- User wants to enhance a vague prompt with codebase context
+- You need to explore unfamiliar code before making changes
+
+## Commands
+
+### Search - Find code by meaning
+
+```bash
+sgrep "authentication middleware"
+sgrep "database connection handling"
+sgrep "error handling patterns"
+```
+
+Use natural language to describe what you're looking for. Returns file paths and relevant code snippets from the entire codebase.
+
+### Ask - Get explanations about the codebase
+
+```bash
+sgrep ask "how does the authentication system work?"
+sgrep ask "what patterns are used for API endpoints?"
+```
+
+Ask questions in natural language and get synthesized explanations with code references.
+
+### Enhance - Improve prompts with codebase context
+
+```bash
+sgrep enhance "fix the bug"
+sgrep enhance "add authentication"
+```
+
+Takes a vague prompt and enhances it using codebase context to make it clearer, more specific, and actionable.
+
+## Examples
+
+### Good Usage
+
+```bash
+sgrep "user login handling"
+sgrep "HashRouter configuration"
+sgrep "React Router setup"
+sgrep ask "how does the caching layer work?"
+sgrep ask "what is the routing architecture?"
+```
+
+### Avoid
+
+```bash
+cd src && sgrep "query"  # WRONG: don't cd first
+sgrep "function"         # Too vague, be more specific
+sgrep "const"            # Use regular grep for exact text matching
+```
+
+## Tips
+
+- **Run from project root** - sgrep searches the entire codebase automatically
+- **Never use cd** - it limits your search and misses related code
+- Use descriptive natural language queries
+- For exact text matching, use regular grep instead
+- Use `sgrep ask` when you need explanations, not just code snippets
+
+## Keywords
+
+semantic search, code search, grep, files, local files, codebase, find code,
+search by meaning, natural language search, code understanding, prompt enhancement

package/build/utils/config.d.ts

@@ -0,0 +1,26 @@
+export interface SgrepConfig {
+    defaultDir?: string;
+    maxResults?: number;
+    outputFormat?: "pretty" | "json";
+    noColor?: boolean;
+    debug?: boolean;
+}
+/**
+ * Loads configuration with cascading priority:
+ * 1. CLI flags (handled by caller)
+ * 2. Environment variables
+ * 3. Local config file (.sgreprc.json)
+ * 4. Global config file (~/.config/sgrep/config.json)
+ */
+export declare function loadConfig(workingDir?: string): SgrepConfig;
+/**
+ * Merges CLI options with config, CLI options take precedence.
+ */
+export declare function mergeWithCliOptions(config: SgrepConfig, cliOptions: {
+    dir?: string;
+    maxResults?: number;
+    json?: boolean;
+    noColor?: boolean;
+    debug?: boolean;
+}): SgrepConfig;
+//# sourceMappingURL=config.d.ts.map

package/build/utils/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/utils/config.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AA4CD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,GAAE,MAAsB,GAAG,WAAW,CAuC1E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE;IACV,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GACA,WAAW,CAoBb"}