@askexenow/exe-os 0.9.127 → 0.9.129

package/dist/chunk-AJWFPKQS.js

@@ -0,0 +1,573 @@
+import {
+  partitionTools
+} from "./chunk-JQ6TLNIV.js";
+import {
+  checkPermission
+} from "./chunk-PRKVT4KN.js";
+
+// src/runtime/compact.ts
+var COMPACTION_THRESHOLD = 0.85;
+var KEEP_RECENT_MESSAGES = 10;
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      chars += msg.content.length;
+    } else {
+      for (const block of msg.content) {
+        if (block.type === "text") chars += block.text.length;
+        else if (block.type === "tool_use") chars += JSON.stringify(block.input).length + block.name.length;
+        else if (block.type === "tool_result") chars += block.content.length;
+      }
+    }
+  }
+  return Math.ceil(chars / 4);
+}
+function needsCompaction(messages, contextLimit) {
+  return estimateTokens(messages) > contextLimit * COMPACTION_THRESHOLD;
+}
+function stripMediaBlocks(messages) {
+  return messages.map((msg) => {
+    if (typeof msg.content === "string") return msg;
+    const filtered = msg.content.filter(
+      (block) => block.type !== "tool_use" || !isMediaTool(block.name)
+    );
+    if (filtered.length === 0) {
+      return { ...msg, content: "[media content removed for compaction]" };
+    }
+    return { ...msg, content: filtered };
+  });
+}
+function isMediaTool(name) {
+  return ["upload_image", "screenshot", "render_image"].includes(name);
+}
+async function compactMessages(messages, provider, summaryModel) {
+  if (messages.length <= KEEP_RECENT_MESSAGES) {
+    return { messages, removedCount: 0 };
+  }
+  const toSummarize = messages.slice(0, -KEEP_RECENT_MESSAGES);
+  const toKeep = messages.slice(-KEEP_RECENT_MESSAGES);
+  const stripped = stripMediaBlocks(toSummarize);
+  const effectiveSummaryModel = summaryModel ?? provider.defaultModel;
+  if (!effectiveSummaryModel) {
+    return {
+      messages: [
+        { role: "user", content: "[Earlier conversation history was compacted due to context limits]" },
+        { role: "assistant", content: "Understood. Continuing with recent context." },
+        ...toKeep
+      ],
+      removedCount: toSummarize.length
+    };
+  }
+  const serialized = stripped.map((m) => {
+    const content = typeof m.content === "string" ? m.content : m.content.map((b) => {
+      if (b.type === "text") return b.text;
+      if (b.type === "tool_use") return `[tool: ${b.name}(${JSON.stringify(b.input).slice(0, 200)})]`;
+      if (b.type === "tool_result") return `[result: ${b.content.slice(0, 200)}]`;
+      return "";
+    }).join("\n");
+    return `${m.role}: ${content}`;
+  }).join("\n\n");
+  try {
+    const summary = await provider.createMessage({
+      model: effectiveSummaryModel,
+      system: "Summarize this conversation concisely. Preserve: decisions made, files modified, current task status, blockers, key findings. Be specific about file paths and tool results.",
+      messages: [{ role: "user", content: serialized.slice(0, 5e4) }],
+      // Cap input
+      maxTokens: 2e3
+    });
+    const summaryText = summary.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+    return {
+      messages: [
+        { role: "user", content: `[Previous conversation summary]
+${summaryText}` },
+        { role: "assistant", content: "Understood. I have context from the summary. Continuing." },
+        ...toKeep
+      ],
+      removedCount: toSummarize.length
+    };
+  } catch {
+    return {
+      messages: [
+        { role: "user", content: "[Earlier conversation history was compacted due to context limits]" },
+        { role: "assistant", content: "Understood. Continuing with recent context." },
+        ...toKeep
+      ],
+      removedCount: toSummarize.length
+    };
+  }
+}
+
+// src/runtime/context-manager.ts
+var MODEL_CONTEXT_LIMITS = {
+  // Anthropic
+  "claude-opus-4": 2e5,
+  "claude-sonnet-4": 2e5,
+  "claude-haiku-4": 2e5,
+  // Extended context variants
+  "claude-opus-4-6": 1e6,
+  "claude-sonnet-4-6": 1e6,
+  // OpenAI
+  "gpt-4o": 128e3,
+  "gpt-4-turbo": 128e3,
+  "gpt-4": 8192,
+  "o3": 2e5,
+  "o4-mini": 2e5,
+  // Google
+  "gemini-2.0": 1e6,
+  "gemini-2.5-pro": 1e6,
+  "gemini-2.5-flash": 1e6,
+  // Local / small models
+  "llama": 8192,
+  "mistral": 32768,
+  "qwen": 32768,
+  "deepseek": 64e3
+};
+var DEFAULT_CONTEXT_LIMIT = 2e5;
+var PRESSURE_THRESHOLDS = [50, 70, 90];
+function getContextLimit(model) {
+  if (model in MODEL_CONTEXT_LIMITS) {
+    return MODEL_CONTEXT_LIMITS[model];
+  }
+  let bestMatch = "";
+  let bestLimit = DEFAULT_CONTEXT_LIMIT;
+  for (const [prefix, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+    if (model.startsWith(prefix) && prefix.length > bestMatch.length) {
+      bestMatch = prefix;
+      bestLimit = limit;
+    }
+  }
+  return bestLimit;
+}
+function createContextManager(model, hooks) {
+  return new ContextManager(model, hooks);
+}
+var ContextManager = class {
+  state;
+  hooks;
+  constructor(model, hooks) {
+    this.hooks = hooks;
+    this.state = {
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedTokens: 0,
+      maxTokens: getContextLimit(model),
+      thresholdsEmitted: /* @__PURE__ */ new Set(),
+      model
+    };
+  }
+  /** Get current context state (read-only snapshot) */
+  getState() {
+    return { ...this.state, thresholdsEmitted: new Set(this.state.thresholdsEmitted) };
+  }
+  /** Get current token usage (best available: API data or estimate) */
+  get usedTokens() {
+    if (this.state.inputTokens > 0) {
+      return this.state.inputTokens;
+    }
+    return this.state.estimatedTokens;
+  }
+  /** Get percent of context used */
+  get percentUsed() {
+    return Math.round(this.usedTokens / this.state.maxTokens * 100);
+  }
+  /**
+   * Update with API usage data (from LLM response).
+   * This is the most accurate source of token counts.
+   */
+  updateFromApiUsage(inputTokens, outputTokens) {
+    this.state.inputTokens = inputTokens;
+    this.state.outputTokens = outputTokens;
+  }
+  /**
+   * Update with estimated tokens from message content.
+   * Used as fallback when API doesn't report cache-aware usage.
+   */
+  updateFromMessages(messages) {
+    this.state.estimatedTokens = estimateTokens(messages);
+  }
+  /**
+   * Check context pressure and emit threshold events.
+   * Should be called after each turn.
+   */
+  async checkPressure() {
+    const percent = this.percentUsed;
+    for (const threshold of PRESSURE_THRESHOLDS) {
+      if (percent >= threshold && !this.state.thresholdsEmitted.has(threshold)) {
+        this.state.thresholdsEmitted.add(threshold);
+        const event = {
+          threshold,
+          usedTokens: this.usedTokens,
+          maxTokens: this.state.maxTokens,
+          percentUsed: percent
+        };
+        if (this.hooks.onContextPressure) {
+          try {
+            await this.hooks.onContextPressure(event);
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  /** Should compaction run? (85% threshold, matching compact.ts) */
+  shouldCompact() {
+    return this.usedTokens > this.state.maxTokens * 0.85;
+  }
+  /**
+   * Pre-compaction: fire hooks and extract critical context to protect.
+   * Returns strings that must survive compaction.
+   */
+  async preCompact(messages) {
+    const protectedContext = [];
+    const memoriesToExtract = [];
+    if (this.hooks.onCompact) {
+      try {
+        await this.hooks.onCompact(messages.length, 0);
+      } catch {
+      }
+    }
+    const DECISION_PATTERNS = /\b(decided|chose|selected|fixed|resolved|implemented|created|deleted|changed|updated|configured)\b/i;
+    const FILE_PATTERNS = /(?:(?:src|lib|bin|tests?)\/[\w/.-]+\.(?:ts|js|json|md))/g;
+    for (const msg of messages) {
+      const text = typeof msg.content === "string" ? msg.content : msg.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+      if (text.length > 50 && DECISION_PATTERNS.test(text)) {
+        const firstSentence = text.split(/[.\n]/).find((s) => DECISION_PATTERNS.test(s));
+        if (firstSentence) {
+          memoriesToExtract.push(firstSentence.trim().slice(0, 200));
+        }
+      }
+      const files = text.match(FILE_PATTERNS);
+      if (files && files.length > 0) {
+        protectedContext.push(`Files referenced: ${[...new Set(files)].join(", ")}`);
+      }
+    }
+    return { protectedContext, memoriesToExtract };
+  }
+  /**
+   * Post-compaction: fire hooks and verify state.
+   */
+  async postCompact(removedCount, summaryLength) {
+    this.state.estimatedTokens = 0;
+    const currentPercent = this.percentUsed;
+    for (const threshold of PRESSURE_THRESHOLDS) {
+      if (currentPercent < threshold) {
+        this.state.thresholdsEmitted.delete(threshold);
+      }
+    }
+    if (this.hooks.onPostCompact) {
+      try {
+        await this.hooks.onPostCompact(removedCount, `Compacted ${removedCount} messages into ${summaryLength} chars`);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Switch model mid-session (e.g., failover).
+   * Recalculates context limit.
+   */
+  switchModel(newModel) {
+    this.state.model = newModel;
+    this.state.maxTokens = getContextLimit(newModel);
+    this.state.thresholdsEmitted.clear();
+  }
+};
+
+// src/runtime/denial-tracking.ts
+var DENIAL_LIMITS = {
+  maxConsecutive: 3,
+  maxTotal: 10
+};
+function createDenialTrackingState() {
+  return {
+    consecutiveDenials: 0,
+    totalDenials: 0
+  };
+}
+function recordDenial(state) {
+  return {
+    consecutiveDenials: state.consecutiveDenials + 1,
+    totalDenials: state.totalDenials + 1
+  };
+}
+function recordSuccess(state) {
+  if (state.consecutiveDenials === 0) return state;
+  return {
+    ...state,
+    consecutiveDenials: 0
+  };
+}
+function shouldFallbackToAsk(state) {
+  return state.consecutiveDenials >= DENIAL_LIMITS.maxConsecutive || state.totalDenials >= DENIAL_LIMITS.maxTotal;
+}
+function shouldWarnDenials(state) {
+  return state.consecutiveDenials === DENIAL_LIMITS.maxConsecutive;
+}
+
+// src/runtime/agent-loop.ts
+async function* agentLoop(userMessage, history, config) {
+  const messages = [
+    ...history,
+    { role: "user", content: userMessage }
+  ];
+  const totalUsage = { inputTokens: 0, outputTokens: 0 };
+  const abortController = config.abortController ?? new AbortController();
+  const context = {
+    cwd: config.cwd,
+    agentId: config.agentId,
+    abortSignal: abortController.signal,
+    sessionState: /* @__PURE__ */ new Map()
+  };
+  const allowedTools = config.tools.toAllowedNormalizedTools(config.permissions);
+  const contextManager = createContextManager(config.model, config.hooks);
+  let denialState = createDenialTrackingState();
+  let turns = 0;
+  while (turns < config.maxTurns) {
+    turns++;
+    if (abortController.signal.aborted) {
+      yield { type: "aborted", reason: "Agent stopped by user" };
+      break;
+    }
+    if (config.maxTokenBudget && totalUsage.inputTokens + totalUsage.outputTokens >= config.maxTokenBudget) {
+      yield { type: "error", error: new Error("Token budget exceeded") };
+      break;
+    }
+    let response;
+    try {
+      response = await config.provider.createMessage({
+        model: config.model,
+        system: config.systemPrompt,
+        messages,
+        tools: allowedTools.length > 0 ? allowedTools : void 0,
+        maxTokens: 4096
+      });
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      yield { type: "error", error };
+      if (config.hooks.onError) await config.hooks.onError(error, context);
+      break;
+    }
+    totalUsage.inputTokens += response.usage.inputTokens;
+    totalUsage.outputTokens += response.usage.outputTokens;
+    if (config.tokenBudgetMiddleware) {
+      const result = await config.tokenBudgetMiddleware.onTokenUsed(
+        response.usage.inputTokens,
+        response.usage.outputTokens
+      );
+      if (result.warned && config.hooks.onNotification) {
+        await config.hooks.onNotification(
+          `\u26A0\uFE0F Token budget at ${result.percentUsed}%. Fallback model: ${result.fallback ?? "none (task will terminate at 100%)"}.`
+        );
+      }
+      if (result.exceeded) {
+        if (config.hooks.onTokenBudgetExceeded) {
+          await config.hooks.onTokenBudgetExceeded(context, result.fallback);
+        }
+        abortController.abort();
+        yield { type: "error", error: new Error("Token budget exceeded. Task requires manual continuation.") };
+        break;
+      }
+    }
+    contextManager.updateFromApiUsage(response.usage.inputTokens, response.usage.outputTokens);
+    contextManager.updateFromMessages(messages);
+    await contextManager.checkPressure();
+    if (contextManager.shouldCompact() && messages.length > 12) {
+      const { memoriesToExtract } = await contextManager.preCompact(
+        messages.slice(0, -10)
+      );
+      if (memoriesToExtract.length > 0 && config.hooks.onNotification) {
+        await config.hooks.onNotification(
+          `Pre-compaction: extracted ${memoriesToExtract.length} key decisions to memory`
+        );
+      }
+      const compacted = await compactMessages(messages, config.provider, config.model);
+      const removedCount = compacted.removedCount;
+      if (removedCount > 0) {
+        messages.length = 0;
+        messages.push(...compacted.messages);
+        await contextManager.postCompact(removedCount, messages[0]?.content?.toString().length ?? 0);
+      }
+    }
+    for (const block of response.content) {
+      if (block.type === "text" && block.text) {
+        yield { type: "text", text: block.text };
+      }
+    }
+    messages.push({ role: "assistant", content: response.content });
+    if (response.stopReason === "end_turn" || response.stopReason === "max_tokens") {
+      yield { type: "turn_complete", turn: turns, usage: response.usage };
+      break;
+    }
+    const toolUseBlocks = response.content.filter(
+      (b) => b.type === "tool_use"
+    );
+    if (toolUseBlocks.length === 0) {
+      yield { type: "turn_complete", turn: turns, usage: response.usage };
+      break;
+    }
+    const { concurrent, sequential } = partitionTools(toolUseBlocks, config.tools);
+    const toolResults = [];
+    if (concurrent.length > 0) {
+      const concurrentResults = await Promise.all(
+        concurrent.map(
+          (block) => executeToolBlock(
+            block,
+            config,
+            context,
+            denialState
+          )
+        )
+      );
+      for (let i = 0; i < concurrent.length; i++) {
+        const block = concurrent[i];
+        const execResult = concurrentResults[i];
+        denialState = execResult.denialState;
+        yield execResult.event;
+        if (execResult.permissionEvent) yield execResult.permissionEvent;
+        yield { type: "tool_result", name: block.name, id: block.id, result: execResult.result };
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: block.id,
+          content: execResult.result.content,
+          is_error: execResult.result.isError
+        });
+      }
+    }
+    for (const block of sequential) {
+      const typedBlock = block;
+      const execResult = await executeToolBlock(typedBlock, config, context, denialState);
+      denialState = execResult.denialState;
+      yield execResult.event;
+      if (execResult.permissionEvent) yield execResult.permissionEvent;
+      yield { type: "tool_result", name: typedBlock.name, id: typedBlock.id, result: execResult.result };
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: typedBlock.id,
+        content: execResult.result.content,
+        is_error: execResult.result.isError
+      });
+    }
+    messages.push({ role: "user", content: toolResults });
+    yield { type: "turn_complete", turn: turns, usage: response.usage };
+  }
+  yield { type: "done", totalUsage, turns };
+}
+async function executeToolBlock(block, config, context, denialState) {
+  const startEvent = { type: "tool_use_start", name: block.name, id: block.id };
+  let permissionEvent;
+  const tool = config.tools.get(block.name);
+  if (!tool) {
+    return {
+      result: { content: `Unknown tool: "${block.name}"`, isError: true },
+      event: startEvent,
+      denialState
+    };
+  }
+  if (!tool.isReadOnly) {
+    if (tool.checkPermissions) {
+      try {
+        const toolPerm = await tool.checkPermissions(block.input, context);
+        if (toolPerm.behavior === "deny") {
+          denialState = recordDenial(denialState);
+          if (shouldWarnDenials(denialState)) {
+            process.stderr.write(
+              `[agent] WARNING: ${denialState.consecutiveDenials} consecutive tool denials
+`
+            );
+          }
+          return {
+            result: {
+              content: `Permission denied${toolPerm.bypassImmune ? " (safety check)" : ""}: ${toolPerm.reason ?? "blocked by tool policy"}`,
+              isError: true
+            },
+            event: { type: "tool_denied", name: block.name, id: block.id, reason: toolPerm.reason ?? "denied" },
+            denialState
+          };
+        }
+      } catch {
+        denialState = recordDenial(denialState);
+        return {
+          result: { content: "Permission check failed (fail-closed)", isError: true },
+          event: { type: "tool_denied", name: block.name, id: block.id, reason: "permission check error (fail-closed)" },
+          denialState
+        };
+      }
+    }
+    const effectivePermissions = shouldFallbackToAsk(denialState) ? { ...config.permissions, defaultMode: "ask" } : config.permissions;
+    const perm = checkPermission(block.name, effectivePermissions);
+    if (!perm.allowed) {
+      if (perm.mode === "ask" && config.permissionHandler) {
+        const inp = block.input;
+        const filePath = inp.file_path ?? inp.filePath;
+        const description = tool.description;
+        const permReq = { name: block.name, id: block.id, description, filePath };
+        const decision = await config.permissionHandler(permReq);
+        permissionEvent = { type: "permission_request", name: block.name, id: block.id, description, filePath };
+        if (decision === "allow") {
+        } else {
+          denialState = recordDenial(denialState);
+          return {
+            result: { content: `Permission denied by user`, isError: true },
+            event: { type: "tool_denied", name: block.name, id: block.id, reason: "denied by user" },
+            denialState,
+            permissionEvent: { type: "permission_request", name: block.name, id: block.id, description, filePath }
+          };
+        }
+      } else {
+        denialState = recordDenial(denialState);
+        return {
+          result: { content: `Permission denied: ${perm.reason}`, isError: true },
+          event: { type: "tool_denied", name: block.name, id: block.id, reason: perm.reason ?? "denied" },
+          denialState
+        };
+      }
+    }
+  }
+  if (context.abortSignal.aborted) {
+    return {
+      result: { content: "Interrupted by user", isError: true },
+      event: { type: "aborted", reason: "Agent stopped by user" },
+      denialState
+    };
+  }
+  if (config.hooks.beforeToolUse) {
+    const intercepted = await config.hooks.beforeToolUse(block, context);
+    if (intercepted) {
+      return { result: intercepted, event: startEvent, denialState };
+    }
+  }
+  let result;
+  try {
+    result = await tool.call(block.input, context);
+    denialState = recordSuccess(denialState);
+  } catch (err) {
+    result = {
+      content: `Tool error: ${err instanceof Error ? err.message : String(err)}`,
+      isError: true
+    };
+    if (config.hooks.onError) {
+      await config.hooks.onError(
+        err instanceof Error ? err : new Error(String(err)),
+        context
+      );
+    }
+  }
+  if (config.hooks.afterToolUse) {
+    await config.hooks.afterToolUse(block, result, context);
+  }
+  return { result, event: startEvent, denialState, permissionEvent };
+}
+
+export {
+  estimateTokens,
+  needsCompaction,
+  compactMessages,
+  getContextLimit,
+  createContextManager,
+  ContextManager,
+  createDenialTrackingState,
+  recordDenial,
+  recordSuccess,
+  shouldFallbackToAsk,
+  agentLoop
+};

package/dist/chunk-AVE2B4DQ.js

@@ -0,0 +1,140 @@
+// src/runtime/dangerous-patterns.ts
+var DANGEROUS_PATTERNS = [
+  // Destructive file operations
+  {
+    regex: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|(-[a-zA-Z]*f[a-zA-Z]*r))\s+[/~*]/,
+    severity: "critical",
+    reason: "Recursive force delete of root, home, or wildcard path"
+  },
+  {
+    regex: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|(-[a-zA-Z]*f[a-zA-Z]*r))\s+\./,
+    severity: "warning",
+    reason: "Recursive force delete of relative path"
+  },
+  // Destructive git operations
+  {
+    regex: /\bgit\s+push\s+--force\b/,
+    severity: "warning",
+    reason: "Force push can overwrite remote history"
+  },
+  {
+    regex: /\bgit\s+reset\s+--hard\b/,
+    severity: "warning",
+    reason: "Hard reset discards all uncommitted changes"
+  },
+  {
+    regex: /\bgit\s+clean\s+-[a-zA-Z]*f/,
+    severity: "warning",
+    reason: "Git clean force removes untracked files"
+  },
+  // Shell injection / expansion in paths
+  {
+    regex: /\$\(.*\)/,
+    severity: "warning",
+    reason: "Command substitution in shell command"
+  },
+  {
+    regex: /`[^`]+`/,
+    severity: "warning",
+    reason: "Backtick command substitution"
+  },
+  // Remote code execution
+  {
+    regex: /\bcurl\b.*\|\s*(bash|sh|zsh)\b/,
+    severity: "critical",
+    reason: "Remote code execution via curl pipe to shell"
+  },
+  {
+    regex: /\bwget\b.*\|\s*(bash|sh|zsh)\b/,
+    severity: "critical",
+    reason: "Remote code execution via wget pipe to shell"
+  },
+  // Privilege escalation
+  {
+    regex: /\bsudo\b/,
+    severity: "warning",
+    reason: "Privilege escalation via sudo"
+  },
+  {
+    regex: /\bchmod\s+777\b/,
+    severity: "warning",
+    reason: "Setting world-writable permissions"
+  },
+  // Dangerous disk operations
+  {
+    regex: /\bdd\s+.*of=\/dev\//,
+    severity: "critical",
+    reason: "Direct disk write can destroy data"
+  },
+  {
+    regex: /\bmkfs\b/,
+    severity: "critical",
+    reason: "Filesystem creation destroys existing data"
+  },
+  // Process/system manipulation
+  {
+    regex: /\bkillall\b/,
+    severity: "warning",
+    reason: "Killing all processes by name"
+  },
+  {
+    regex: /\bkill\s+-9\b/,
+    severity: "warning",
+    reason: "Force kill signal"
+  },
+  // MCP bypass — agents must use MCP tools, never access the DB directly.
+  // These patterns catch attempts to work around a disconnected MCP server.
+  {
+    regex: /\bsqlite3\b.*\bmemories\.db\b/,
+    severity: "critical",
+    reason: "Direct SQLite access bypasses MCP contract boundary \u2014 use MCP tools"
+  },
+  {
+    regex: /\bsqlite3\b.*\.exe-os\b/,
+    severity: "critical",
+    reason: "Direct SQLite access to exe-os database \u2014 use MCP tools"
+  },
+  {
+    regex: /\bnode\s+-e\b.*\b(better-sqlite3|libsql|sqlite3)\b/,
+    severity: "critical",
+    reason: "Inline Node.js script accessing SQLite directly \u2014 use MCP tools"
+  },
+  {
+    regex: /\brequire\s*\(\s*['"].*memories\.db['"]\s*\)/,
+    severity: "critical",
+    reason: "Direct require of memories database \u2014 use MCP tools"
+  },
+  {
+    regex: /\bcat\b.*\bmemories\.db\b/,
+    severity: "warning",
+    reason: "Reading raw database file \u2014 encrypted data, use MCP tools instead"
+  }
+];
+function checkDangerousPatterns(command) {
+  const matched = [];
+  for (const rule of DANGEROUS_PATTERNS) {
+    if (rule.regex.test(command)) {
+      matched.push({
+        pattern: rule.regex.source,
+        severity: rule.severity,
+        reason: rule.reason
+      });
+    }
+  }
+  return {
+    dangerous: matched.length > 0,
+    patterns: matched
+  };
+}
+function hasCriticalPattern(result) {
+  return result.patterns.some((p) => p.severity === "critical");
+}
+function formatDangerousPatterns(patterns) {
+  return patterns.map((p) => `[${p.severity.toUpperCase()}] ${p.reason}`).join("\n");
+}
+
+export {
+  checkDangerousPatterns,
+  hasCriticalPattern,
+  formatDangerousPatterns
+};