@hawkeyexl/manni 4.5.0 → 4.7.0

package/dist/chunk-D6RO54QD.js

@@ -0,0 +1,674 @@
+#!/usr/bin/env node
+import {
+  emptyWindow,
+  materialize,
+  windowOf
+} from "./chunk-CWXZ2MRT.js";
+import {
+  extractEvals,
+  findGitRoot,
+  listInTree,
+  resolveArtifacts,
+  safeRead
+} from "./chunk-OOEMKOX6.js";
+import {
+  configDir
+} from "./chunk-4TSWU2SU.js";
+import {
+  makeRedactor
+} from "./chunk-CU57HT2E.js";
+import {
+  extractFrontmatter
+} from "./chunk-MSMB6XOS.js";
+
+// src/tracevals/rules/turn.ts
+var INJECTED = /<(system-reminder|task-notification|ci-monitor-event|local-command-stdout|local-command-stderr|local-command-caveat)>[\s\S]*?<\/\1>/g;
+var MARKER = /^(?:Stop hook feedback:|SubagentStop hook feedback:|\[Request interrupted by user)/;
+var TYPED_TURN_ORIGINS = /* @__PURE__ */ new Set(["human", "sdk"]);
+var WORK = /* @__PURE__ */ new Set(["assistant", "tool_call", "tool_result"]);
+function isTypedPrompt(event) {
+  if (event.kind !== "user" || event.text === void 0) return false;
+  const { raw } = event;
+  if (raw.isMeta === true || raw.isCompactSummary === true) return false;
+  const origin = raw.origin;
+  if (typeof origin === "object" && origin !== null && "kind" in origin && typeof origin.kind === "string") {
+    if (!TYPED_TURN_ORIGINS.has(origin.kind)) return false;
+  } else if (typeof raw.turnOrigin === "string" && !TYPED_TURN_ORIGINS.has(raw.turnOrigin)) {
+    return false;
+  }
+  const rest = event.text.replace(INJECTED, "").trim();
+  return rest !== "" && !MARKER.test(rest);
+}
+function lastTurn(trace) {
+  const prompts = trace.events.filter((e) => e.sidechain !== true && isTypedPrompt(e));
+  const sessionTurnCount = prompts.length;
+  const to = trace.events.length - 1;
+  const last = prompts.at(-1);
+  if (last === void 0) {
+    return {
+      window: emptyWindow("turn", "last turn", "the trace holds no prompt the user typed"),
+      from: to + 1,
+      to,
+      sessionTurnCount
+    };
+  }
+  return slice(trace, last.index, [last], /* @__PURE__ */ new Set([void 0]), sessionTurnCount, {
+    label: "last turn",
+    reason: "nothing happened after the last prompt the user typed"
+  });
+}
+function subagentTurn(trace) {
+  const prompts = trace.events.filter(isTypedPrompt);
+  return slice(
+    trace,
+    0,
+    prompts,
+    new Set(trace.events.map((e) => e.branchId)),
+    prompts.length,
+    { label: "subagent run", reason: "the subagent recorded no work" }
+  );
+}
+function slice(trace, from, prompts, own, sessionTurnCount, words) {
+  const to = trace.events.length - 1;
+  const worked = trace.events.some((e) => e.index > from && WORK.has(e.kind));
+  if (!worked) {
+    return {
+      window: emptyWindow("turn", words.label, words.reason),
+      from,
+      to,
+      sessionTurnCount
+    };
+  }
+  const window = materialize(
+    trace,
+    "turn",
+    words.label,
+    [{ start: from, end: Number.POSITIVE_INFINITY }],
+    void 0,
+    own
+  );
+  window.userMessages = prompts.map((p) => p.text ?? "");
+  window.turnCount = sessionTurnCount;
+  return { window, from, to, sessionTurnCount };
+}
+
+// src/tracevals/rules/sources.ts
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import picomatch from "picomatch";
+var MAX_IMPORT_HOPS = 4;
+var Collector = class {
+  constructor(cwd, root, home, exclude) {
+    this.cwd = cwd;
+    this.root = root;
+    this.home = home;
+    const match = exclude.length > 0 ? picomatch(exclude, { dot: true }) : null;
+    this.excluded = (path) => match !== null && match(this.display(path));
+    this.excludedName = (name) => exclude.includes(name);
+  }
+  cwd;
+  root;
+  home;
+  sources = [];
+  warnings = [];
+  seen = /* @__PURE__ */ new Set();
+  parsed = /* @__PURE__ */ new Map();
+  excluded;
+  /** Whether `exclude` lists, as it is, the name of a source with no file, such as `prompt`. */
+  excludedName;
+  display(path) {
+    const inRoot = relPosix(this.root, path);
+    if (inRoot !== null) return inRoot;
+    const inHome = relPosix(this.home, path);
+    if (inHome !== null) return `~/${inHome}`;
+    return path.split(sep).join("/");
+  }
+  has(path) {
+    return this.seen.has(key(path));
+  }
+  /** The file's front matter, or null when it has none or it does not parse. */
+  front(path, content) {
+    const k = key(path);
+    if (this.parsed.has(k)) return this.parsed.get(k) ?? null;
+    let parsed = null;
+    try {
+      const fm = extractFrontmatter(content, "markdown");
+      parsed = fm.present ? fm : null;
+    } catch (err) {
+      const loose = isCursorRule(path) ? cursorFront(content) : null;
+      if (loose !== null) {
+        this.parsed.set(k, loose);
+        return loose;
+      }
+      const first = (err instanceof Error ? err.message : String(err)).split("\n")[0] ?? "";
+      this.warnings.push(
+        `${this.display(path)}: front matter does not parse (${first}), so it is read as having none`
+      );
+    }
+    this.parsed.set(k, parsed);
+    return parsed;
+  }
+  /** Adds a source once. Returns it, or null when excluded or already listed. */
+  add(path, content, format, trigger, skill) {
+    if (this.has(path) || this.excluded(path)) return null;
+    this.seen.add(key(path));
+    const source = {
+      path,
+      displayPath: this.display(path),
+      format,
+      trigger,
+      content,
+      sha256: createHash("sha256").update(content).digest("hex"),
+      blocks: true
+    };
+    if (skill !== void 0) source.skill = skill;
+    const declared = this.declared(path, content);
+    if (declared !== void 0) source.declaredRules = declared;
+    this.sources.push(source);
+    return source;
+  }
+  /**
+   * Adds a source that says what the session was asked, or one the transcript
+   * recorded. These never declare evals. With no file, its display path is its
+   * format, and `exclude` matches that name.
+   */
+  addRequest(file, content, format, trigger, blocks = true) {
+    if (EXCLUDABLE_BY_NAME.has(format) && this.excludedName(format)) return;
+    if (file !== null) {
+      if (this.has(file) || this.excluded(file)) return;
+      this.seen.add(key(file));
+    }
+    this.sources.push({
+      path: file ?? "",
+      displayPath: file === null ? format : this.display(file),
+      format,
+      trigger,
+      content,
+      sha256: createHash("sha256").update(content).digest("hex"),
+      blocks
+    });
+  }
+  declared(path, content) {
+    const fm = this.front(path, content);
+    if (fm === null) return void 0;
+    const extracted = extractEvals(
+      { name: basename(path), type: "project-rules", path, content, origin: "project" },
+      fm
+    );
+    if (extracted.errors.length > 0) {
+      this.warnings.push(
+        `${this.display(path)}: metadata.evals does not validate (${extracted.errors[0]?.message ?? "invalid"}), so it declares no rules`
+      );
+      return void 0;
+    }
+    const rules = [];
+    for (const entry of extracted.evals) {
+      if (entry.grader !== "ai" || entry.assertion === void 0) continue;
+      const rule = { id: entry.id, text: entry.assertion };
+      const when = entry.options?.when;
+      if (isRecord(when)) rule.when = when;
+      rules.push(rule);
+    }
+    return rules.length > 0 ? rules : void 0;
+  }
+};
+async function resolveAlwaysSources(opts) {
+  const c = await collector(opts);
+  for (const candidate of await catalog(c, opts)) {
+    if (candidate.trigger.kind === "always") await addWithImports(c, candidate, "always");
+  }
+  await addDesignated(c, opts);
+  return { sources: c.sources, warnings: c.warnings };
+}
+async function resolveTurnSources(trace, turn, opts) {
+  const c = await collector(opts);
+  const touches = trace.fileAccesses.filter((a) => a.index <= turn.to).map((a) => {
+    const abs = resolve(c.cwd, a.path);
+    return { abs, rel: relPosix(c.root, abs), read: a.op === "read" };
+  });
+  const wasRead = new Set(touches.filter((t) => t.read).map((t) => key(t.abs)));
+  for (const candidate of await catalog(c, opts)) {
+    const { trigger } = candidate;
+    if (trigger.kind === "always") {
+      await addWithImports(c, candidate, "always");
+    } else if (trigger.kind === "read") {
+      if (wasRead.has(key(candidate.path))) await addWithImports(c, candidate, "read");
+    } else {
+      const match = picomatch(trigger.patterns, { dot: true });
+      const hit = touches.find((t) => t.rel !== null && match(t.rel));
+      if (hit !== void 0 && hit.rel !== null) {
+        await addWithImports(c, candidate, `${trigger.key} matched ${hit.rel}`);
+      }
+    }
+  }
+  const nested = /* @__PURE__ */ new Map();
+  for (const touch of touches) {
+    if (touch.rel === null) continue;
+    for (const dir of dirsBelowCwd(c, dirname(touch.abs))) {
+      if (!nested.has(dir)) nested.set(dir, touch.rel);
+    }
+  }
+  const dirs = [...nested.keys()].sort((a, b) => a.length - b.length);
+  for (const dir of dirs) {
+    const touched = nested.get(dir) ?? "";
+    for (const [name, format] of NESTED_FILES) {
+      const path = join(dir, name);
+      const content = await safeRead(path);
+      if (content !== null) {
+        await addWithImports(c, { path, format, trigger: { kind: "always" } }, `touched ${touched}`, content);
+      }
+    }
+  }
+  await addWindowed(c, trace, turn, touches, opts);
+  await addDesignated(c, opts);
+  addPrompts(c, trace, turn);
+  await addPlan(c, trace, turn, opts);
+  await addSpecs(c, touches, opts.plans ?? []);
+  await addSystemPrompt(c, trace, turn, opts);
+  return { sources: c.sources, warnings: c.warnings };
+}
+var EXCLUDABLE_BY_NAME = /* @__PURE__ */ new Set(["prompt", "plan", "system-prompt"]);
+var BOUNDARY_MARKER = "__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__";
+function lastAttachment(trace, turn, type) {
+  for (let i = trace.events.length - 1; i >= 0; i -= 1) {
+    const event = trace.events[i];
+    if (event === void 0 || event.kind !== "meta" || event.index > turn.to) continue;
+    const attachment = event.raw.attachment;
+    if (event.raw.type === "attachment" && isRecord(attachment) && attachment.type === type) {
+      return { index: event.index, record: event.raw, attachment };
+    }
+  }
+  return void 0;
+}
+async function addSystemPrompt(c, trace, turn, opts) {
+  const scrub = makeRedactor(opts.redact ?? []);
+  const style = lastAttachment(trace, turn, "output_style_instructions")?.attachment.style;
+  const styleName = isRecord(style) && typeof style.name === "string" ? style.name : void 0;
+  const stylePrompt = isRecord(style) && typeof style.prompt === "string" ? style.prompt : void 0;
+  let builtIn;
+  if (styleName !== void 0 && stylePrompt !== void 0) {
+    const file = await userStyleFile(c, opts, styleName);
+    if (file === void 0) builtIn = stylePrompt;
+    else c.addRequest(file, scrub(stylePrompt), "output-style", `style ${styleName}`);
+  }
+  const snapshot = lastAttachment(trace, turn, "prompt_snapshot");
+  const recorded = snapshot?.attachment.systemPrompt;
+  if (snapshot === void 0 || !Array.isArray(recorded)) return;
+  const blocks = recorded.filter((b) => typeof b === "string");
+  const custom = !blocks.includes(BOUNDARY_MARKER);
+  const content = scrub([...blocks, ...builtIn !== void 0 ? [builtIn] : []].join("\n\n"));
+  const { version } = snapshot.record;
+  const by = typeof version === "string" ? `, Claude Code ${version}` : "";
+  const trigger = `recorded at turn ${String(snapshot.index)}${by}${custom ? ", custom" : ""}`;
+  c.addRequest(
+    null,
+    content,
+    "system-prompt",
+    trigger,
+    /* blocks= */
+    custom
+  );
+}
+async function userStyleFile(c, opts, name) {
+  const dirs = [.../* @__PURE__ */ new Set([c.cwd, c.root])].map((b) => join(b, ".claude", "output-styles"));
+  dirs.push(join(configDir(opts.env), "output-styles"));
+  for (const dir of dirs) {
+    for (const path of await listInTree(dir, (p) => p.endsWith(".md"), { maxDepth: 0 })) {
+      const declared = (await frontOf(c, path))?.name;
+      if ((typeof declared === "string" ? declared : basename(path, ".md")) === name) return path;
+    }
+  }
+  return void 0;
+}
+function addPrompts(c, trace, turn) {
+  const typed = trace.events.filter((e) => e.index <= turn.to && isTypedPrompt(e));
+  const main = typed.filter((e) => e.sidechain !== true);
+  const prompts = main.length > 0 ? main : typed;
+  if (prompts.length === 0) return;
+  const content = prompts.map((p, i) => `${String(i + 1)}. ${(p.text ?? "").trim()}`).join("\n\n");
+  c.addRequest(null, content, "prompt", `typed prompts 1-${String(prompts.length)}`);
+}
+async function addPlan(c, trace, turn, opts) {
+  const approved = trace.toolCalls.filter((call) => call.name === "ExitPlanMode" && call.index <= turn.to).filter((call) => isApproved(trace, call.index, turn.to)).at(-1);
+  if (approved === void 0) return;
+  const trigger = `approved at turn ${String(approved.index)}`;
+  const plan = approved.input.plan;
+  if (typeof plan === "string" && plan.trim() !== "") {
+    c.addRequest(null, plan, "plan", trigger);
+    return;
+  }
+  const plansDir = join(configDir(opts.env), "plans");
+  const file = trace.fileAccesses.filter((a) => a.op !== "read" && a.index < approved.index).map((a) => resolve(c.cwd, a.path)).filter((abs) => relPosix(plansDir, abs) !== null).at(-1);
+  if (file === void 0) return;
+  const content = await safeRead(file);
+  if (content !== null) c.addRequest(file, content, "plan", trigger);
+}
+function isApproved(trace, index, to) {
+  const id = trace.events.find((e) => e.index === index)?.raw.id;
+  if (typeof id !== "string") return false;
+  for (const event of trace.events) {
+    if (event.kind !== "tool_result" || event.index <= index || event.index > to) continue;
+    const message = event.raw.message;
+    const blocks = isRecord(message) ? message.content : void 0;
+    if (!Array.isArray(blocks)) continue;
+    for (const block of blocks) {
+      if (isRecord(block) && block.type === "tool_result" && block.tool_use_id === id) {
+        return block.is_error !== true;
+      }
+    }
+  }
+  return false;
+}
+var SPEC_FILES = {
+  "speckit-spec": ["spec.md", "plan.md", "tasks.md"],
+  "kiro-spec": ["requirements.md", "design.md", "tasks.md"]
+};
+function specDirOf(rel) {
+  const parts = rel.split("/");
+  const [first, second, third] = parts;
+  if (first === "specs" && second !== void 0 && parts.length > 2) {
+    return { dir: `specs/${second}`, format: "speckit-spec" };
+  }
+  if (first === ".kiro" && second === "specs" && third !== void 0 && parts.length > 3) {
+    return { dir: `.kiro/specs/${third}`, format: "kiro-spec" };
+  }
+  if (first === "openspec" && second === "changes" && third !== void 0 && third !== "archive" && parts.length > 3) {
+    return { dir: `openspec/changes/${third}`, format: "openspec-change" };
+  }
+  return null;
+}
+async function addSpecs(c, touches, plans) {
+  const isPlan = plans.length > 0 ? picomatch(plans, { dot: true }) : null;
+  const done = /* @__PURE__ */ new Set();
+  for (const touch of touches) {
+    const { rel } = touch;
+    if (rel === null) continue;
+    const trigger = `touched ${rel}`;
+    const spec = specDirOf(rel);
+    if (spec !== null && !done.has(spec.dir)) {
+      done.add(spec.dir);
+      const dir = join(c.root, ...spec.dir.split("/"));
+      const files = spec.format === "openspec-change" ? await listInTree(dir, (p) => p.endsWith(".md")) : SPEC_FILES[spec.format].map((name) => join(dir, name));
+      for (const file of files) {
+        const content = await safeRead(file);
+        if (content !== null) c.addRequest(file, content, spec.format, trigger);
+      }
+    }
+    if (isPlan?.(rel) === true) {
+      const content = await safeRead(touch.abs);
+      if (content !== null) c.addRequest(touch.abs, content, "plans", trigger);
+    }
+  }
+}
+async function addDesignated(c, opts) {
+  const include = opts.include ?? [];
+  if (include.length === 0) return;
+  const match = picomatch(include, { dot: true });
+  const found = await listInTree(c.root, (abs) => {
+    const rel = relPosix(c.root, abs);
+    return rel !== null && match(rel);
+  });
+  for (const abs of found) {
+    if (c.has(abs)) continue;
+    const content = await safeRead(abs);
+    if (content === null) {
+      c.warnings.push(`${c.display(abs)}: matched conformance.include but could not be read`);
+      continue;
+    }
+    c.add(abs, content, "designated", "always");
+  }
+}
+async function addWindowed(c, trace, turn, touches, opts) {
+  const { artifacts } = await resolveArtifacts(
+    {
+      ...trace,
+      agentSpawns: opts.agentType === void 0 ? [] : [{ subagentType: opts.agentType, index: 0 }]
+    },
+    { projectDir: c.cwd, projectRoot: c.root, ...opts.env ? { env: opts.env } : {} }
+  );
+  for (const artifact of artifacts) {
+    if (artifact.type === "agent") {
+      c.add(artifact.path, artifact.content, "agent", "subagent run");
+      continue;
+    }
+    if (artifact.type !== "skill" && artifact.type !== "slash-command") continue;
+    const window = windowOf(trace, artifact);
+    if (!window.events.some((e) => e.index <= turn.to)) continue;
+    if (artifact.type === "slash-command") {
+      c.add(artifact.path, artifact.content, "slash-command", "slash command window");
+      continue;
+    }
+    c.add(artifact.path, artifact.content, "skill", "skill window", artifact.name);
+    const skillDir = dirname(artifact.path);
+    for (const touch of touches) {
+      if (!touch.read || relPosix(skillDir, touch.abs) === null || c.has(touch.abs)) continue;
+      const content = await safeRead(touch.abs);
+      if (content !== null) {
+        c.add(touch.abs, content, "skill", `read under skill ${artifact.name}`, artifact.name);
+      }
+    }
+  }
+}
+var ANCESTOR_FILES = [
+  ["CLAUDE.md", "claude-md"],
+  ["CLAUDE.local.md", "claude-md"],
+  [join(".claude", "CLAUDE.md"), "claude-md"],
+  ["AGENTS.md", "agents-md"],
+  [join(".claude", "AGENTS.md"), "agents-md"],
+  ["GEMINI.md", "gemini-md"]
+];
+var NESTED_FILES = [
+  ["CLAUDE.md", "claude-md"],
+  ["AGENTS.md", "agents-md"],
+  ["GEMINI.md", "gemini-md"]
+];
+async function catalog(c, opts) {
+  const out = [];
+  const userClaude = configDir(opts.env);
+  const always = { kind: "always" };
+  out.push({ path: join(userClaude, "CLAUDE.md"), format: "claude-md", trigger: always });
+  out.push({ path: join(c.home, ".gemini", "GEMINI.md"), format: "gemini-md", trigger: always });
+  for (const dir of ancestors(c.cwd, c.root).reverse()) {
+    for (const [name, format] of ANCESTOR_FILES) {
+      out.push({ path: join(dir, name), format, trigger: always });
+    }
+  }
+  const bases = c.cwd === c.root ? [c.root] : [c.root, c.cwd];
+  for (const dir of [join(userClaude, "rules"), ...bases.map((b) => join(b, ".claude", "rules"))]) {
+    for (const path of await listInTree(dir, (p) => p.endsWith(".md"))) {
+      out.push({ path, format: "claude-rule", trigger: await claudeRuleTrigger(c, path) });
+    }
+  }
+  for (const base of bases) {
+    const dir = join(base, ".cursor", "rules");
+    for (const path of await listInTree(dir, (p) => p.endsWith(".mdc") || p.endsWith(".md"))) {
+      const trigger = await cursorTrigger(c, path);
+      if (trigger !== null) out.push({ path, format: "cursor-rule", trigger });
+    }
+  }
+  for (const dir of [join(c.home, ".kiro", "steering"), ...bases.map((b) => join(b, ".kiro", "steering"))]) {
+    for (const path of await listInTree(dir, (p) => p.endsWith(".md"), { maxDepth: 0 })) {
+      out.push({ path, format: "kiro-steering", trigger: await kiroTrigger(c, path) });
+    }
+  }
+  for (const base of bases) {
+    out.push({
+      path: join(base, ".specify", "memory", "constitution.md"),
+      format: "speckit-constitution",
+      trigger: always
+    });
+    out.push({ path: join(base, "openspec", "project.md"), format: "openspec-project", trigger: { kind: "read" } });
+  }
+  return out;
+}
+async function frontOf(c, path) {
+  const content = await safeRead(path);
+  if (content === null) return null;
+  return c.front(path, content)?.data ?? null;
+}
+async function claudeRuleTrigger(c, path) {
+  const patterns = globList((await frontOf(c, path))?.paths);
+  return patterns.length > 0 ? { kind: "globs", key: "paths", patterns } : { kind: "always" };
+}
+async function cursorTrigger(c, path) {
+  const fm = await frontOf(c, path);
+  if (fm === null && !path.endsWith(".mdc")) return null;
+  if (fm?.alwaysApply === true) return { kind: "always" };
+  const patterns = globList(fm?.globs);
+  return patterns.length > 0 ? { kind: "globs", key: "globs", patterns } : { kind: "read" };
+}
+async function kiroTrigger(c, path) {
+  const fm = await frontOf(c, path);
+  const inclusion = fm?.inclusion;
+  if (inclusion === void 0 || inclusion === "always") return { kind: "always" };
+  if (inclusion === "fileMatch") {
+    const patterns = globList(fm?.fileMatchPattern);
+    if (patterns.length > 0) return { kind: "globs", key: "fileMatchPattern", patterns };
+  }
+  return { kind: "read" };
+}
+async function addWithImports(c, candidate, trigger, known) {
+  if (c.has(candidate.path)) return;
+  const content = known ?? await safeRead(candidate.path);
+  if (content === null) return;
+  const added = c.add(candidate.path, content, candidate.format, trigger);
+  if (added === null || candidate.format !== "claude-md" && candidate.format !== "gemini-md") {
+    return;
+  }
+  let frontier = [added];
+  for (let hop = 1; hop <= MAX_IMPORT_HOPS && frontier.length > 0; hop += 1) {
+    const next = [];
+    for (const importer of frontier) {
+      for (const ref of importsOf(importer.content)) {
+        const path = ref.startsWith("~/") ? join(c.home, ref.slice(2)) : resolve(dirname(importer.path), ref);
+        if (c.has(path)) continue;
+        const body = await safeRead(path);
+        if (body === null) continue;
+        const source = c.add(path, body, "import", `imported by ${importer.displayPath}`);
+        if (source !== null) next.push(source);
+      }
+    }
+    frontier = next;
+  }
+}
+function importsOf(content) {
+  const refs = [];
+  let fence = null;
+  for (const line of content.split(/\r?\n/)) {
+    const marker = /^\s*(`{3,}|~{3,})/.exec(line)?.[1];
+    if (marker !== void 0) {
+      const char = marker.charAt(0);
+      if (fence === null) {
+        fence = { char, length: marker.length };
+        continue;
+      }
+      if (char === fence.char && marker.length >= fence.length && line.trim() === marker) {
+        fence = null;
+        continue;
+      }
+    }
+    if (fence !== null) continue;
+    const prose = line.replace(/`[^`]*`/g, "");
+    for (const m of prose.matchAll(/(?:^|\s)@([^\s`]+)/g)) {
+      const ref = m[1]?.replace(/[.,;:!?)\]]+$/, "");
+      if (ref) refs.push(ref);
+    }
+  }
+  return refs;
+}
+async function collector(opts) {
+  const cwd = resolve(opts.projectDir);
+  const root = resolve(opts.projectRoot ?? await findGitRoot(cwd) ?? cwd);
+  return new Collector(cwd, root, homeDir(opts.env), opts.exclude ?? []);
+}
+function homeDir(env = process.env) {
+  const set = process.platform === "win32" ? env.USERPROFILE ?? env.HOME : env.HOME;
+  return resolve(set ?? homedir());
+}
+function ancestors(cwd, root) {
+  const dirs = [];
+  let current = cwd;
+  for (let depth = 0; depth < 32; depth += 1) {
+    dirs.push(current);
+    if (current === root) break;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return dirs;
+}
+function dirsBelowCwd(c, dir) {
+  const dirs = [];
+  let current = dir;
+  for (let depth = 0; depth < 64; depth += 1) {
+    if (relPosix(c.root, current) === null || relPosix(current, c.cwd) !== null) break;
+    dirs.push(current);
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return dirs;
+}
+function isCursorRule(path) {
+  return path.split(sep).join("/").includes("/.cursor/rules/");
+}
+function cursorFront(content) {
+  const block = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content)?.[1];
+  if (block === void 0) return null;
+  const data = {};
+  for (const line of block.split(/\r?\n/)) {
+    const m = /^(description|globs|alwaysApply):\s*(.*)$/.exec(line);
+    const name = m?.[1];
+    const value = m?.[2]?.trim();
+    if (name === void 0 || value === void 0) continue;
+    data[name] = name === "alwaysApply" ? value === "true" : value;
+  }
+  if (Object.keys(data).length === 0) return null;
+  return { data, present: true, format: "markdown", lineFor: () => void 0 };
+}
+function globList(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string" && v.trim() !== "").map((v) => v.trim());
+  }
+  if (typeof value !== "string") return [];
+  const out = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of value) {
+    if (ch === "{") depth += 1;
+    if (ch === "}") depth = Math.max(0, depth - 1);
+    if (ch === "," && depth === 0) {
+      out.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  out.push(current);
+  return out.map((p) => p.trim()).filter((p) => p !== "");
+}
+function relPosix(base, path) {
+  const rel = relative(base, path);
+  if (rel === "") return "";
+  if (rel.startsWith("..") || isAbsolute(rel)) return null;
+  return rel.split(sep).join("/");
+}
+function key(path) {
+  const abs = resolve(path);
+  return process.platform === "win32" ? abs.toLowerCase() : abs;
+}
+var pathKey = key;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  isTypedPrompt,
+  lastTurn,
+  subagentTurn,
+  resolveAlwaysSources,
+  resolveTurnSources,
+  pathKey
+};
+//# sourceMappingURL=chunk-D6RO54QD.js.map