opencode-rules-md 0.8.2 → 0.8.4

package/dist/tui/index.js

@@ -1,13 +1,848 @@
-import { jsx as _jsx } from "@opentui/solid/jsx-runtime";
-import { SidebarContent } from './slots/sidebar-content.js';
-const id = 'opencode-rules-md';
-const tui = async (api) => {
-    api.slots.register({
-        order: 350,
-        slots: {
-            sidebar_content: (ctx, props) => (_jsx(SidebarContent, { sessionId: props.session_id, api: api, theme: ctx.theme })),
-        },
+// @bun
+var __require = import.meta.require;
+
+// tui/index.tsx
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+
+// tui/slots/sidebar-content.tsx
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createSignal, createEffect, createMemo, onCleanup, Show, For } from "solid-js";
+
+// src/rule-discovery.ts
+import { stat, readFile, readdir } from "fs/promises";
+import path from "path";
+import os from "os";
+
+// src/debug.ts
+function createDebugLog(prefix = "[opencode-rules-md]") {
+  return (message) => {
+    if (process.env.OPENCODE_RULES_DEBUG) {
+      console.debug(`${prefix} ${message}`);
+    }
+  };
+}
+
+// src/rule-metadata.ts
+var { parse: parseYaml } = await import("yaml");
+function extractStringArray(value) {
+  if (!Array.isArray(value)) {
+    return;
+  }
+  const result = value.filter((v) => typeof v === "string").map((v) => v.trim()).filter((v) => v.length > 0);
+  return result.length > 0 ? result : undefined;
+}
+function parseRuleMetadata(content) {
+  if (!content.startsWith("---")) {
+    return;
+  }
+  const endIndex = content.indexOf("---", 3);
+  if (endIndex === -1) {
+    return;
+  }
+  const frontmatter = content.substring(3, endIndex).trim();
+  if (!frontmatter) {
+    return;
+  }
+  try {
+    const parsed = parseYaml(frontmatter);
+    if (!parsed || typeof parsed !== "object") {
+      return;
+    }
+    const metadata = {};
+    const arrayFields = [
+      "globs",
+      "keywords",
+      "tools",
+      "model",
+      "agent",
+      "command",
+      "project",
+      "branch",
+      "os"
+    ];
+    for (const field of arrayFields) {
+      const extracted = extractStringArray(parsed[field]);
+      if (extracted) {
+        metadata[field] = extracted;
+      }
+    }
+    if (typeof parsed.ci === "boolean") {
+      metadata.ci = parsed.ci;
+    }
+    if (parsed.match === "any" || parsed.match === "all") {
+      metadata.match = parsed.match;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : undefined;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[opencode-rules-md] Warning: Failed to parse YAML frontmatter: ${message}`);
+    return;
+  }
+}
+function stripFrontmatter(content) {
+  if (!content.startsWith("---")) {
+    return content;
+  }
+  const endIndex = content.indexOf("---", 3);
+  if (endIndex === -1) {
+    return content;
+  }
+  return content.substring(endIndex + 3).trimStart();
+}
+
+// src/rule-discovery.ts
+var debugLog = createDebugLog();
+var ruleCache = new Map;
+async function getCachedRule(filePath) {
+  try {
+    const stats = await stat(filePath);
+    const mtime = stats.mtimeMs;
+    const cached = ruleCache.get(filePath);
+    if (cached && cached.mtime === mtime) {
+      debugLog(`Cache hit: ${filePath}`);
+      return cached;
+    }
+    debugLog(`Cache miss: ${filePath}`);
+    const content = await readFile(filePath, "utf-8");
+    const metadata = parseRuleMetadata(content);
+    const strippedContent = stripFrontmatter(content);
+    const entry = {
+      content,
+      metadata,
+      strippedContent,
+      mtime
+    };
+    ruleCache.set(filePath, entry);
+    return entry;
+  } catch (error) {
+    ruleCache.delete(filePath);
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[opencode-rules-md] Warning: Failed to read rule file ${filePath}: ${message}`);
+    return;
+  }
+}
+function getGlobalRulesDir() {
+  const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR;
+  if (opencodeConfigDir) {
+    return path.join(opencodeConfigDir, "rules");
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+  if (xdgConfigHome) {
+    return path.join(xdgConfigHome, "opencode", "rules");
+  }
+  const homeDir = process.env.HOME || os.homedir();
+  return path.join(homeDir, ".config", "opencode", "rules");
+}
+async function scanDirectoryRecursively(dir, baseDir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await scanDirectoryRecursively(fullPath, baseDir));
+      } else if (entry.name.endsWith(".md") || entry.name.endsWith(".mdc")) {
+        const relativePath = path.relative(baseDir, fullPath);
+        results.push({ filePath: fullPath, relativePath });
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return results;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`[opencode-rules-md] Warning: Failed to read directory ${dir}: ${message}`);
+  }
+  return results;
+}
+async function discoverRuleFiles(projectDir) {
+  const files = [];
+  const globalRulesDir = getGlobalRulesDir();
+  if (globalRulesDir) {
+    const globalRules = await scanDirectoryRecursively(globalRulesDir, globalRulesDir);
+    for (const { filePath, relativePath } of globalRules) {
+      debugLog(`Discovered global rule: ${relativePath} (${filePath})`);
+      files.push({ filePath, relativePath });
+    }
+  }
+  if (projectDir) {
+    const projectRulesDir = path.join(projectDir, ".opencode", "rules");
+    const projectRules = await scanDirectoryRecursively(projectRulesDir, projectRulesDir);
+    for (const { filePath, relativePath } of projectRules) {
+      debugLog(`Discovered project rule: ${relativePath} (${filePath})`);
+      files.push({ filePath, relativePath });
+    }
+  }
+  return files;
+}
+
+// src/active-rules-state.ts
+import * as fs from "fs/promises";
+import * as os2 from "os";
+import * as path2 from "path";
+var debugLog2 = createDebugLog();
+var writeQueues = new Map;
+var stateDirOverride = null;
+var SAFE_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+function isValidSessionId(sessionId) {
+  return SAFE_SESSION_ID_PATTERN.test(sessionId);
+}
+function resolveStateDir() {
+  if (stateDirOverride !== null) {
+    return stateDirOverride;
+  }
+  return path2.join(os2.homedir(), ".opencode", "state", "opencode-rules-md");
+}
+function getStateFilePath(sessionId) {
+  if (!isValidSessionId(sessionId)) {
+    throw new Error(`Invalid sessionId: ${sessionId}`);
+  }
+  return path2.join(resolveStateDir(), `${sessionId}.json`);
+}
+async function readActiveRulesState(sessionId) {
+  if (!isValidSessionId(sessionId)) {
+    debugLog2(`Invalid sessionId rejected: ${sessionId}`);
+    return null;
+  }
+  const filePath = getStateFilePath(sessionId);
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!isValidActiveRulesState(parsed)) {
+      debugLog2(`Invalid active rules state format for session ${sessionId}`);
+      return null;
+    }
+    return parsed;
+  } catch (error) {
+    debugLog2(`Failed to read active rules state for session ${sessionId}: ${error}`);
+    return null;
+  }
+}
+function isValidActiveRulesState(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const obj = value;
+  if (typeof obj["sessionId"] !== "string") {
+    return false;
+  }
+  if (typeof obj["evaluatedAt"] !== "number") {
+    return false;
+  }
+  if (!Array.isArray(obj["matchedRulePaths"])) {
+    return false;
+  }
+  for (const item of obj["matchedRulePaths"]) {
+    if (typeof item !== "string") {
+      return false;
+    }
+  }
+  return true;
+}
+
+// tui/data/rules.ts
+import path3 from "path";
+async function loadSidebarRules(projectDir, sessionId) {
+  const discovered = await discoverRuleFiles(projectDir ?? undefined);
+  const activeState = sessionId ? await readActiveRulesState(sessionId) : null;
+  const hasEvaluationState = activeState !== null;
+  const matchedPathsSet = hasEvaluationState ? new Set(activeState.matchedRulePaths) : null;
+  const entries = [];
+  let skippedCount = 0;
+  for (const rule of discovered) {
+    const cached = await getCachedRule(rule.filePath);
+    if (!cached) {
+      skippedCount++;
+      continue;
+    }
+    const meta = cached.metadata;
+    const source = ruleSource(rule.filePath, projectDir);
+    const isConditional = hasConditions(meta);
+    const conditionSummary = isConditional ? formatConditionSummary(meta) : "always active";
+    let isActive;
+    if (matchedPathsSet !== null) {
+      isActive = matchedPathsSet.has(rule.filePath);
+    } else {
+      isActive = isConditional ? null : true;
+    }
+    entries.push({
+      name: "",
+      path: rule.relativePath,
+      source,
+      isConditional,
+      conditionSummary,
+      metadata: meta ?? {},
+      isActive
     });
+  }
+  disambiguateNames(entries);
+  const activeOrder = (v) => v === true ? 0 : v === null ? 1 : 2;
+  entries.sort((a, b) => {
+    if (a.source !== b.source)
+      return a.source === "project" ? -1 : 1;
+    const activeCmp = activeOrder(a.isActive) - activeOrder(b.isActive);
+    if (activeCmp !== 0)
+      return activeCmp;
+    const nameCompare = a.name.localeCompare(b.name);
+    if (nameCompare !== 0)
+      return nameCompare;
+    return a.path.localeCompare(b.path);
+  });
+  return { rules: entries, skippedCount, hasEvaluationState };
+}
+function ruleSource(filePath, projectDir) {
+  if (!projectDir)
+    return "global";
+  const projectRulesPrefix = path3.join(projectDir, ".opencode", "rules") + path3.sep;
+  return filePath.startsWith(projectRulesPrefix) ? "project" : "global";
+}
+function hasConditions(meta) {
+  if (!meta)
+    return false;
+  return !!(meta.globs || meta.keywords || meta.tools || meta.model || meta.agent || meta.command || meta.project || meta.branch || meta.os || meta.ci !== undefined);
+}
+function formatConditionSummary(meta) {
+  const parts = [];
+  const arrayFields = [
+    ["globs", "globs"],
+    ["keywords", "keywords"],
+    ["tools", "tools"],
+    ["model", "model"],
+    ["agent", "agent"],
+    ["command", "command"],
+    ["project", "project"],
+    ["branch", "branch"],
+    ["os", "os"]
+  ];
+  for (const [field, label] of arrayFields) {
+    const value = meta[field];
+    if (Array.isArray(value) && value.length > 0) {
+      parts.push(`${label}: ${value.join(", ")}`);
+    }
+  }
+  if (meta.ci !== undefined) {
+    parts.push(`ci: ${String(meta.ci)}`);
+  }
+  if (meta.match) {
+    parts.push(`match: ${meta.match}`);
+  }
+  return parts.join(", ");
+}
+function disambiguateNames(entries) {
+  for (const entry of entries) {
+    const basename = path3.basename(entry.path);
+    const dotIndex = basename.lastIndexOf(".");
+    entry.name = dotIndex > 0 ? basename.substring(0, dotIndex) : basename;
+  }
+  const stemCounts = new Map;
+  for (const entry of entries) {
+    stemCounts.set(entry.name, (stemCounts.get(entry.name) ?? 0) + 1);
+  }
+  for (const entry of entries) {
+    if ((stemCounts.get(entry.name) ?? 0) <= 1)
+      continue;
+    const dir = path3.dirname(entry.path);
+    if (dir && dir !== ".") {
+      const parent = path3.basename(dir);
+      entry.name = `${parent}/${entry.name}`;
+    }
+  }
+  const nameCounts = new Map;
+  for (const entry of entries) {
+    nameCounts.set(entry.name, (nameCounts.get(entry.name) ?? 0) + 1);
+  }
+  for (const entry of entries) {
+    if ((nameCounts.get(entry.name) ?? 0) > 1) {
+      entry.name = entry.path;
+    }
+  }
+}
+
+// tui/slots/sidebar-content.tsx
+function RuleSection(props) {
+  const activeCount = createMemo(() => props.rules.filter((r) => r.isActive === true).length);
+  const headerCount = createMemo(() => {
+    if (props.hasEvaluationState) {
+      return `(${activeCount()}/${props.rules.length})`;
+    }
+    return `(${props.rules.length})`;
+  });
+  const bulletColor = (rule) => {
+    return rule.isActive === true ? props.theme.success : props.theme.textMuted;
+  };
+  return _$createComponent(Show, {
+    get when() {
+      return props.rules.length > 0;
+    },
+    get children() {
+      var _el$ = _$createElement("box"), _el$2 = _$createElement("box"), _el$3 = _$createElement("text"), _el$4 = _$createElement("text");
+      _$insertNode(_el$, _el$2);
+      _$insertNode(_el$2, _el$3);
+      _$insertNode(_el$2, _el$4);
+      _$setProp(_el$2, "flexDirection", "row");
+      _$setProp(_el$2, "gap", 1);
+      _$setProp(_el$2, "onMouseDown", () => props.onToggle());
+      _$insert(_el$3, () => props.open ? "\u25BC" : "\u25B6");
+      _$insert(_el$4, () => props.title, null);
+      _$insert(_el$4, _$createComponent(Show, {
+        get when() {
+          return !props.open;
+        },
+        get children() {
+          var _el$5 = _$createElement("span"), _el$6 = _$createTextNode(` `);
+          _$insertNode(_el$5, _el$6);
+          _$insert(_el$5, headerCount, null);
+          _$effect((_$p) => _$setProp(_el$5, "style", {
+            fg: props.theme.textMuted
+          }, _$p));
+          return _el$5;
+        }
+      }), null);
+      _$insert(_el$, _$createComponent(Show, {
+        get when() {
+          return props.open;
+        },
+        get children() {
+          return _$createComponent(For, {
+            get each() {
+              return props.rules;
+            },
+            children: (rule, localIndex) => {
+              const globalIndex = () => props.globalOffset + localIndex();
+              return (() => {
+                var _el$7 = _$createElement("box"), _el$8 = _$createElement("box"), _el$9 = _$createElement("text"), _el$1 = _$createElement("text");
+                _$insertNode(_el$7, _el$8);
+                _$setProp(_el$7, "flexDirection", "column");
+                _$setProp(_el$7, "onMouseDown", () => props.onExpandToggle(globalIndex()));
+                _$insertNode(_el$8, _el$9);
+                _$insertNode(_el$8, _el$1);
+                _$setProp(_el$8, "flexDirection", "row");
+                _$setProp(_el$8, "gap", 1);
+                _$insertNode(_el$9, _$createTextNode(`\u2022`));
+                _$insert(_el$1, () => rule.name);
+                _$insert(_el$7, _$createComponent(Show, {
+                  get when() {
+                    return props.expandedIndex === globalIndex();
+                  },
+                  get children() {
+                    var _el$10 = _$createElement("box"), _el$11 = _$createElement("text");
+                    _$insertNode(_el$10, _el$11);
+                    _$setProp(_el$10, "flexDirection", "column");
+                    _$setProp(_el$10, "paddingLeft", 4);
+                    _$insert(_el$11, () => rule.path);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.globs?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$12 = _$createElement("text"), _el$13 = _$createTextNode(`Globs: `);
+                        _$insertNode(_el$12, _el$13);
+                        _$insert(_el$12, () => rule.metadata.globs.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$12, "fg", props.theme.textMuted, _$p));
+                        return _el$12;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.keywords?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$14 = _$createElement("text"), _el$15 = _$createTextNode(`Keywords: `);
+                        _$insertNode(_el$14, _el$15);
+                        _$insert(_el$14, () => rule.metadata.keywords.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$14, "fg", props.theme.textMuted, _$p));
+                        return _el$14;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.tools?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$16 = _$createElement("text"), _el$17 = _$createTextNode(`Tools: `);
+                        _$insertNode(_el$16, _el$17);
+                        _$insert(_el$16, () => rule.metadata.tools.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$16, "fg", props.theme.textMuted, _$p));
+                        return _el$16;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.model?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$18 = _$createElement("text"), _el$19 = _$createTextNode(`Model: `);
+                        _$insertNode(_el$18, _el$19);
+                        _$insert(_el$18, () => rule.metadata.model.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$18, "fg", props.theme.textMuted, _$p));
+                        return _el$18;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.agent?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$20 = _$createElement("text"), _el$21 = _$createTextNode(`Agent: `);
+                        _$insertNode(_el$20, _el$21);
+                        _$insert(_el$20, () => rule.metadata.agent.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$20, "fg", props.theme.textMuted, _$p));
+                        return _el$20;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.command?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$22 = _$createElement("text"), _el$23 = _$createTextNode(`Command: `);
+                        _$insertNode(_el$22, _el$23);
+                        _$insert(_el$22, () => rule.metadata.command.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$22, "fg", props.theme.textMuted, _$p));
+                        return _el$22;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.project?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$24 = _$createElement("text"), _el$25 = _$createTextNode(`Project: `);
+                        _$insertNode(_el$24, _el$25);
+                        _$insert(_el$24, () => rule.metadata.project.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$24, "fg", props.theme.textMuted, _$p));
+                        return _el$24;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.branch?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$26 = _$createElement("text"), _el$27 = _$createTextNode(`Branch: `);
+                        _$insertNode(_el$26, _el$27);
+                        _$insert(_el$26, () => rule.metadata.branch.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$26, "fg", props.theme.textMuted, _$p));
+                        return _el$26;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return (rule.metadata.os?.length ?? 0) > 0;
+                      },
+                      get children() {
+                        var _el$28 = _$createElement("text"), _el$29 = _$createTextNode(`OS: `);
+                        _$insertNode(_el$28, _el$29);
+                        _$insert(_el$28, () => rule.metadata.os.join(", "), null);
+                        _$effect((_$p) => _$setProp(_el$28, "fg", props.theme.textMuted, _$p));
+                        return _el$28;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return rule.metadata.ci !== undefined;
+                      },
+                      get children() {
+                        var _el$30 = _$createElement("text"), _el$31 = _$createTextNode(`CI: `);
+                        _$insertNode(_el$30, _el$31);
+                        _$insert(_el$30, () => String(rule.metadata.ci), null);
+                        _$effect((_$p) => _$setProp(_el$30, "fg", props.theme.textMuted, _$p));
+                        return _el$30;
+                      }
+                    }), null);
+                    _$insert(_el$10, _$createComponent(Show, {
+                      get when() {
+                        return rule.metadata.match;
+                      },
+                      get children() {
+                        var _el$32 = _$createElement("text"), _el$33 = _$createTextNode(`Match: `);
+                        _$insertNode(_el$32, _el$33);
+                        _$insert(_el$32, () => rule.metadata.match, null);
+                        _$effect((_$p) => _$setProp(_el$32, "fg", props.theme.textMuted, _$p));
+                        return _el$32;
+                      }
+                    }), null);
+                    _$effect((_$p) => _$setProp(_el$11, "fg", props.theme.textMuted, _$p));
+                    return _el$10;
+                  }
+                }), null);
+                _$effect((_p$) => {
+                  var _v$3 = bulletColor(rule), _v$4 = props.theme.text;
+                  _v$3 !== _p$.e && (_p$.e = _$setProp(_el$9, "fg", _v$3, _p$.e));
+                  _v$4 !== _p$.t && (_p$.t = _$setProp(_el$1, "fg", _v$4, _p$.t));
+                  return _p$;
+                }, {
+                  e: undefined,
+                  t: undefined
+                });
+                return _el$7;
+              })();
+            }
+          });
+        }
+      }), null);
+      _$effect((_p$) => {
+        var _v$ = props.theme.text, _v$2 = props.theme.text;
+        _v$ !== _p$.e && (_p$.e = _$setProp(_el$3, "fg", _v$, _p$.e));
+        _v$2 !== _p$.t && (_p$.t = _$setProp(_el$4, "fg", _v$2, _p$.t));
+        return _p$;
+      }, {
+        e: undefined,
+        t: undefined
+      });
+      return _el$;
+    }
+  });
+}
+function SidebarContent(props) {
+  const [rules, setRules] = createSignal([]);
+  const [status, setStatus] = createSignal("loading");
+  const [skippedCount, setSkippedCount] = createSignal(0);
+  const [hasEvaluationState, setHasEvaluationState] = createSignal(false);
+  const [expandedIndex, setExpandedIndex] = createSignal(null);
+  const [lastDir, setLastDir] = createSignal(undefined);
+  const [lastSessionId, setLastSessionId] = createSignal(undefined);
+  const [projectOpen, setProjectOpen] = createSignal(false);
+  const [globalOpen, setGlobalOpen] = createSignal(false);
+  const [refreshCounter, setRefreshCounter] = createSignal(0);
+  const theme = () => props.theme.current;
+  const resolveProjectDir = () => {
+    return props.api.state.path.directory ?? null;
+  };
+  let requestId = 0;
+  let debounceTimer = null;
+  const loadRulesInitial = async () => {
+    const thisRequest = ++requestId;
+    const dir = resolveProjectDir();
+    const sessionId = props.sessionId;
+    setLastDir(dir);
+    setLastSessionId(sessionId);
+    setStatus("loading");
+    try {
+      const result = await loadSidebarRules(dir, sessionId);
+      if (requestId !== thisRequest)
+        return;
+      setRules(result.rules);
+      setSkippedCount(result.skippedCount);
+      setHasEvaluationState(result.hasEvaluationState);
+      setStatus("loaded");
+    } catch (err) {
+      if (requestId !== thisRequest)
+        return;
+      console.error("[opencode-rules-md] Failed to load rules:", err);
+      setStatus("error");
+    }
+  };
+  const loadRulesRefresh = async () => {
+    if (status() === "loading")
+      return;
+    const thisRequest = ++requestId;
+    const dir = resolveProjectDir();
+    const sessionId = props.sessionId;
+    try {
+      const result = await loadSidebarRules(dir, sessionId);
+      if (requestId !== thisRequest)
+        return;
+      setRules(result.rules);
+      setSkippedCount(result.skippedCount);
+      setHasEvaluationState(result.hasEvaluationState);
+      setStatus("loaded");
+    } catch (err) {
+      if (requestId !== thisRequest)
+        return;
+      console.error("[opencode-rules-md] Failed to refresh rules:", err);
+    }
+  };
+  createEffect(() => {
+    const currentSessionId = props.sessionId;
+    const currentDir = resolveProjectDir();
+    if (currentSessionId !== lastSessionId() || currentDir !== lastDir()) {
+      if (debounceTimer !== null) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+      }
+      setExpandedIndex(null);
+      setProjectOpen(false);
+      setGlobalOpen(false);
+      loadRulesInitial();
+    }
+  });
+  createEffect(() => {
+    const counter = refreshCounter();
+    if (counter > 0) {
+      loadRulesRefresh();
+    }
+  });
+  const triggerRefresh = (event) => {
+    const eventSessionID = event.properties.sessionID;
+    if (typeof eventSessionID === "string" && eventSessionID !== props.sessionId) {
+      return;
+    }
+    if (debounceTimer !== null) {
+      clearTimeout(debounceTimer);
+    }
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      setRefreshCounter((c) => c + 1);
+    }, 150);
+  };
+  const unsubMessageUpdated = props.api.event.on("message.updated", triggerRefresh);
+  const unsubSessionStatus = props.api.event.on("session.status", triggerRefresh);
+  onCleanup(() => {
+    if (debounceTimer !== null) {
+      clearTimeout(debounceTimer);
+    }
+    unsubMessageUpdated();
+    unsubSessionStatus();
+  });
+  const toggleExpand = (index) => {
+    setExpandedIndex((prev) => prev === index ? null : index);
+  };
+  const projectRules = createMemo(() => rules().filter((r) => r.source === "project"));
+  const globalRules = createMemo(() => rules().filter((r) => r.source === "global"));
+  return (() => {
+    var _el$34 = _$createElement("box"), _el$35 = _$createElement("text"), _el$36 = _$createElement("b");
+    _$insertNode(_el$34, _el$35);
+    _$insertNode(_el$35, _el$36);
+    _$insertNode(_el$36, _$createTextNode(`Rules`));
+    _$insert(_el$34, _$createComponent(Show, {
+      get when() {
+        return status() === "loading";
+      },
+      get children() {
+        var _el$38 = _$createElement("text");
+        _$insertNode(_el$38, _$createTextNode(`Loading...`));
+        _$effect((_$p) => _$setProp(_el$38, "fg", theme().textMuted, _$p));
+        return _el$38;
+      }
+    }), null);
+    _$insert(_el$34, _$createComponent(Show, {
+      get when() {
+        return status() === "error";
+      },
+      get children() {
+        var _el$40 = _$createElement("text");
+        _$insertNode(_el$40, _$createTextNode(`Failed to load rules`));
+        _$effect((_$p) => _$setProp(_el$40, "fg", theme().textMuted, _$p));
+        return _el$40;
+      }
+    }), null);
+    _$insert(_el$34, _$createComponent(Show, {
+      get when() {
+        return status() === "loaded";
+      },
+      get children() {
+        return [_$createComponent(Show, {
+          get when() {
+            return rules().length > 0;
+          },
+          get fallback() {
+            return (() => {
+              var _el$44 = _$createElement("text");
+              _$insertNode(_el$44, _$createTextNode(`No rules found`));
+              _$effect((_$p) => _$setProp(_el$44, "fg", theme().textMuted, _$p));
+              return _el$44;
+            })();
+          },
+          get children() {
+            return [_$createComponent(RuleSection, {
+              title: "Project",
+              get rules() {
+                return projectRules();
+              },
+              get theme() {
+                return theme();
+              },
+              get open() {
+                return projectOpen();
+              },
+              onToggle: () => setProjectOpen((x) => !x),
+              get expandedIndex() {
+                return expandedIndex();
+              },
+              globalOffset: 0,
+              onExpandToggle: toggleExpand,
+              get hasEvaluationState() {
+                return hasEvaluationState();
+              }
+            }), _$createComponent(RuleSection, {
+              title: "Global",
+              get rules() {
+                return globalRules();
+              },
+              get theme() {
+                return theme();
+              },
+              get open() {
+                return globalOpen();
+              },
+              onToggle: () => setGlobalOpen((x) => !x),
+              get expandedIndex() {
+                return expandedIndex();
+              },
+              get globalOffset() {
+                return projectRules().length;
+              },
+              onExpandToggle: toggleExpand,
+              get hasEvaluationState() {
+                return hasEvaluationState();
+              }
+            })];
+          }
+        }), _$createComponent(Show, {
+          get when() {
+            return skippedCount() > 0;
+          },
+          get children() {
+            var _el$42 = _$createElement("text"), _el$43 = _$createTextNode(` rules skipped (unreadable)`);
+            _$insertNode(_el$42, _el$43);
+            _$insert(_el$42, skippedCount, _el$43);
+            _$effect((_$p) => _$setProp(_el$42, "fg", theme().textMuted, _$p));
+            return _el$42;
+          }
+        })];
+      }
+    }), null);
+    _$effect((_$p) => _$setProp(_el$35, "fg", theme().text, _$p));
+    return _el$34;
+  })();
+}
+
+// tui/index.tsx
+var id = "opencode-rules-md";
+var tui = async (api) => {
+  api.slots.register({
+    order: 350,
+    slots: {
+      sidebar_content: (ctx, props) => _$createComponent2(SidebarContent, {
+        get sessionId() {
+          return props.session_id;
+        },
+        api,
+        get theme() {
+          return ctx.theme;
+        }
+      })
+    }
+  });
+};
+var tui_default = {
+  id,
+  tui
+};
+export {
+  tui_default as default
 };
-export default { id, tui };
-//# sourceMappingURL=index.js.map
+
+//# debugId=ED0F9EF9A8B9A40664756E2164756E21
+//# sourceMappingURL=index.js.map