@ashx-j/lunr 0.2.24 → 0.2.25

package/dist/node-runtime/chunk-YCUZEGJG.js

@@ -0,0 +1,1361 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  DefaultPackageManager,
+  require_ignore
+} from "./chunk-LQP3RB67.js";
+import {
+  parseFrontmatter
+} from "./chunk-QFWG2RVL.js";
+import {
+  SettingsManager
+} from "./chunk-6XL67VVY.js";
+import {
+  getGlobalInstructionsPath,
+  loadSelectedUserInstructions
+} from "./chunk-M3LZLQW2.js";
+import {
+  measureStartup,
+  resetTimings
+} from "./chunk-PVCDKGR6.js";
+import {
+  loadThemeFromPath
+} from "./chunk-RDDAZOMU.js";
+import {
+  CONFIG_DIR_NAME,
+  canonicalizePath,
+  getAgentDir,
+  isBunBinary,
+  isLocalPath,
+  isNodeBundle,
+  resolvePath,
+  waitForChildProcess
+} from "./chunk-FQMM2EZ2.js";
+import {
+  __toESM
+} from "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/core/event-bus.js
+import { EventEmitter } from "node:events";
+function createEventBus() {
+  let emitter = new EventEmitter();
+  return {
+    emit: (channel, data) => {
+      emitter.emit(channel, data);
+    },
+    on: (channel, handler) => {
+      let safeHandler = async (data) => {
+        try {
+          await handler(data);
+        } catch (err) {
+          console.error(`Event handler error (${channel}):`, err);
+        }
+      };
+      return emitter.on(channel, safeHandler), () => emitter.off(channel, safeHandler);
+    },
+    clear: () => {
+      emitter.removeAllListeners();
+    }
+  };
+}
+
+// packages/coding-agent/dist/core/source-info.js
+function createSourceInfo(path2, metadata) {
+  return {
+    path: path2,
+    source: metadata.source,
+    scope: metadata.scope,
+    origin: metadata.origin,
+    baseDir: metadata.baseDir
+  };
+}
+function createSyntheticSourceInfo(path2, options) {
+  return {
+    path: path2,
+    source: options.source,
+    scope: options.scope ?? "temporary",
+    origin: options.origin ?? "top-level",
+    baseDir: options.baseDir
+  };
+}
+
+// packages/coding-agent/dist/core/extensions/loader.js
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/coding-agent/dist/core/exec.js
+import { spawn } from "node:child_process";
+async function execCommand(command, args, cwd, options) {
+  return new Promise((resolve5) => {
+    let proc = spawn(command, args, {
+      cwd,
+      shell: !1,
+      stdio: ["ignore", "pipe", "pipe"]
+    }), stdout = "", stderr = "", killed = !1, timeoutId, killProcess = () => {
+      killed || (killed = !0, proc.kill("SIGTERM"), setTimeout(() => {
+        proc.killed || proc.kill("SIGKILL");
+      }, 5e3));
+    };
+    options?.signal && (options.signal.aborted ? killProcess() : options.signal.addEventListener("abort", killProcess, { once: !0 })), options?.timeout && options.timeout > 0 && (timeoutId = setTimeout(() => {
+      killProcess();
+    }, options.timeout)), proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    }), proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    }), waitForChildProcess(proc).then((code) => {
+      timeoutId && clearTimeout(timeoutId), options?.signal && options.signal.removeEventListener("abort", killProcess), resolve5({ stdout, stderr, code: code ?? 0, killed });
+    }).catch((_err) => {
+      timeoutId && clearTimeout(timeoutId), options?.signal && options.signal.removeEventListener("abort", killProcess), resolve5({ stdout, stderr, code: 1, killed });
+    });
+  });
+}
+
+// packages/coding-agent/dist/core/extensions/loader.js
+var bunExtensionHost, createJitiFn;
+var require2 = createRequire(new URL("../core/extensions/loader.js", import.meta.url).href), _aliases = null;
+function getAliases() {
+  if (_aliases)
+    return _aliases;
+  let __dirname = path.dirname(fileURLToPath(new URL("../core/extensions/loader.js", import.meta.url).href)), packageIndex = path.resolve(__dirname, "../..", isNodeBundle ? "node-runtime/index.js" : "index.js"), typeboxEntry = require2.resolve("typebox"), typeboxCompileEntry = require2.resolve("typebox/compile"), typeboxValueEntry = require2.resolve("typebox/value"), packagesRoot = path.resolve(__dirname, "../../../../"), resolveWorkspaceOrImport = (workspaceRelativePath, specifier) => {
+    let workspacePath = path.join(packagesRoot, workspaceRelativePath);
+    return fs.existsSync(workspacePath) ? workspacePath : fileURLToPath(import.meta.resolve(specifier));
+  }, piCodingAgentEntry = packageIndex, piAgentCoreEntry = resolveWorkspaceOrImport("agent/dist/index.js", "@ashx-j/lunr-agent"), piTuiEntry = resolveWorkspaceOrImport("tui/dist/index.js", "@ashx-j/lunr-tui"), piAiCompatEntry = resolveWorkspaceOrImport("ai/dist/compat.js", "@ashx-j/lunr-ai/compat"), piAiOauthEntry = resolveWorkspaceOrImport("ai/dist/oauth.js", "@ashx-j/lunr-ai/oauth"), piAiProvidersEntry = resolveWorkspaceOrImport("ai/dist/providers/all.js", "@ashx-j/lunr-ai/providers/all");
+  return _aliases = {
+    "@ashx-j/lunr": piCodingAgentEntry,
+    "@ashx-j/lunr-agent": piAgentCoreEntry,
+    "@ashx-j/lunr-tui": piTuiEntry,
+    "@ashx-j/lunr-ai/providers/all": piAiProvidersEntry,
+    "@ashx-j/lunr-ai/compat": piAiCompatEntry,
+    "@ashx-j/lunr-ai/oauth": piAiOauthEntry,
+    "@ashx-j/lunr-ai": piAiCompatEntry,
+    "@ashx-j/lunr": piCodingAgentEntry,
+    "@ashx-j/lunr-agent": piAgentCoreEntry,
+    "@ashx-j/lunr-tui": piTuiEntry,
+    "@ashx-j/lunr-ai/providers/all": piAiProvidersEntry,
+    "@ashx-j/lunr-ai/compat": piAiCompatEntry,
+    "@ashx-j/lunr-ai/oauth": piAiOauthEntry,
+    "@ashx-j/lunr-ai": piAiCompatEntry,
+    "@mariozechner/pi-coding-agent": piCodingAgentEntry,
+    "@mariozechner/pi-agent-core": piAgentCoreEntry,
+    "@mariozechner/pi-tui": piTuiEntry,
+    "@mariozechner/pi-ai/providers/all": piAiProvidersEntry,
+    "@mariozechner/pi-ai/compat": piAiCompatEntry,
+    "@mariozechner/pi-ai/oauth": piAiOauthEntry,
+    "@mariozechner/pi-ai": piAiCompatEntry,
+    typebox: typeboxEntry,
+    "typebox/compile": typeboxCompileEntry,
+    "typebox/value": typeboxValueEntry,
+    "@sinclair/typebox": typeboxEntry,
+    "@sinclair/typebox/compile": typeboxCompileEntry,
+    "@sinclair/typebox/value": typeboxValueEntry
+  }, _aliases;
+}
+var extensionCacheCwd, extensionCacheGeneration = 0, extensionCache = /* @__PURE__ */ new Map();
+function clearExtensionCache() {
+  extensionCache.clear(), extensionCacheCwd = void 0, extensionCacheGeneration++;
+}
+function useExtensionCacheCwd(cwd) {
+  let resolvedCwd = resolvePath(cwd);
+  return extensionCacheCwd !== void 0 && extensionCacheCwd !== resolvedCwd && clearExtensionCache(), extensionCacheCwd = resolvedCwd, { cwd: resolvedCwd, generation: extensionCacheGeneration };
+}
+function createExtensionRuntime() {
+  let notInitialized = () => {
+    throw new Error("Extension runtime not initialized. Action methods cannot be called during extension loading.");
+  }, state = {}, runtime = {
+    sendMessage: notInitialized,
+    sendUserMessage: notInitialized,
+    appendEntry: notInitialized,
+    setSessionName: notInitialized,
+    getSessionName: notInitialized,
+    setLabel: notInitialized,
+    getActiveTools: notInitialized,
+    getAllTools: notInitialized,
+    setActiveTools: notInitialized,
+    // registerTool() is valid during extension load; refresh is only needed post-bind.
+    refreshTools: () => {
+    },
+    getCommands: notInitialized,
+    setModel: () => Promise.reject(new Error("Extension runtime not initialized")),
+    getThinkingLevel: notInitialized,
+    setThinkingLevel: notInitialized,
+    flagValues: /* @__PURE__ */ new Map(),
+    pendingProviderRegistrations: [],
+    assertActive: () => {
+      if (state.staleMessage)
+        throw new Error(state.staleMessage);
+    },
+    invalidate: (message) => {
+      state.staleMessage ??= message ?? "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().";
+    },
+    // Pre-bind: queue registrations so bindCore() can flush them once the
+    // model registry is available. bindCore() replaces both with direct calls.
+    registerProvider: (name, config, extensionPath = "<unknown>") => {
+      runtime.pendingProviderRegistrations.push({ name, config, extensionPath });
+    },
+    unregisterProvider: (name) => {
+      runtime.pendingProviderRegistrations = runtime.pendingProviderRegistrations.filter((r) => r.name !== name);
+    }
+  };
+  return runtime;
+}
+function createExtensionAPI(extension, runtime, cwd, eventBus) {
+  return {
+    // Registration methods - write to extension
+    on(event, handler) {
+      runtime.assertActive();
+      let list = extension.handlers.get(event) ?? [];
+      list.push(handler), extension.handlers.set(event, list);
+    },
+    registerTool(tool) {
+      runtime.assertActive(), extension.tools.set(tool.name, {
+        definition: tool,
+        sourceInfo: extension.sourceInfo
+      }), runtime.refreshTools();
+    },
+    registerCommand(name, options) {
+      runtime.assertActive(), extension.commands.set(name, {
+        name,
+        sourceInfo: extension.sourceInfo,
+        ...options
+      });
+    },
+    registerShortcut(shortcut, options) {
+      runtime.assertActive(), extension.shortcuts.set(shortcut, { shortcut, extensionPath: extension.path, ...options });
+    },
+    registerFlag(name, options) {
+      runtime.assertActive(), extension.flags.set(name, { name, extensionPath: extension.path, ...options }), options.default !== void 0 && !runtime.flagValues.has(name) && runtime.flagValues.set(name, options.default);
+    },
+    registerMessageRenderer(customType, renderer) {
+      runtime.assertActive(), extension.messageRenderers.set(customType, renderer);
+    },
+    registerEntryRenderer(customType, renderer) {
+      runtime.assertActive(), extension.entryRenderers ??= /* @__PURE__ */ new Map(), extension.entryRenderers.set(customType, renderer);
+    },
+    // Flag access - checks extension registered it, reads from runtime
+    getFlag(name) {
+      if (runtime.assertActive(), !!extension.flags.has(name))
+        return runtime.flagValues.get(name);
+    },
+    // Action methods - delegate to shared runtime
+    sendMessage(message, options) {
+      runtime.assertActive(), runtime.sendMessage(message, options);
+    },
+    sendUserMessage(content, options) {
+      runtime.assertActive(), runtime.sendUserMessage(content, options);
+    },
+    appendEntry(customType, data) {
+      runtime.assertActive(), runtime.appendEntry(customType, data);
+    },
+    setSessionName(name) {
+      runtime.assertActive(), runtime.setSessionName(name);
+    },
+    getSessionName() {
+      return runtime.assertActive(), runtime.getSessionName();
+    },
+    setLabel(entryId, label) {
+      runtime.assertActive(), runtime.setLabel(entryId, label);
+    },
+    exec(command, args, options) {
+      return runtime.assertActive(), execCommand(command, args, options?.cwd ?? cwd, options);
+    },
+    getActiveTools() {
+      return runtime.assertActive(), runtime.getActiveTools();
+    },
+    getAllTools() {
+      return runtime.assertActive(), runtime.getAllTools();
+    },
+    setActiveTools(toolNames) {
+      runtime.assertActive(), runtime.setActiveTools(toolNames);
+    },
+    getCommands() {
+      return runtime.assertActive(), runtime.getCommands();
+    },
+    setModel(model) {
+      return runtime.assertActive(), runtime.setModel(model);
+    },
+    getThinkingLevel() {
+      return runtime.assertActive(), runtime.getThinkingLevel();
+    },
+    setThinkingLevel(level) {
+      runtime.assertActive(), runtime.setThinkingLevel(level);
+    },
+    registerProvider(name, config) {
+      runtime.assertActive(), runtime.registerProvider(name, config, extension.path);
+    },
+    unregisterProvider(name) {
+      runtime.assertActive(), runtime.unregisterProvider(name, extension.path);
+    },
+    events: eventBus
+  };
+}
+function isCurrentCacheToken(cacheToken) {
+  return cacheToken !== void 0 && extensionCacheCwd === cacheToken.cwd && extensionCacheGeneration === cacheToken.generation;
+}
+async function ensureExtensionHost() {
+  if (createJitiFn)
+    return createJitiFn;
+  if (isBunBinary && bunExtensionHost)
+    return bunExtensionHost.createJiti;
+  let { createJiti } = await import("jiti/static");
+  return createJitiFn = createJiti, createJiti;
+}
+async function loadExtensionModule(extensionPath, cacheToken) {
+  if (isCurrentCacheToken(cacheToken)) {
+    let cachedFactory = extensionCache.get(extensionPath);
+    if (cachedFactory)
+      return cachedFactory;
+  }
+  let factory = await (await ensureExtensionHost())(new URL("../core/extensions/loader.js", import.meta.url).href, {
+    moduleCache: !1,
+    // In Bun binary: use virtualModules for bundled packages (no filesystem resolution)
+    // Also disable tryNative so jiti handles ALL imports (not just the entry point)
+    // In Node.js/dev: use aliases to resolve to node_modules paths
+    ...isBunBinary ? { virtualModules: bunExtensionHost?.virtualModules, tryNative: !1 } : { alias: getAliases() }
+  }).import(extensionPath, { default: !0 });
+  if (typeof factory == "function")
+    return isCurrentCacheToken(cacheToken) && extensionCache.set(extensionPath, factory), factory;
+}
+function createExtension(extensionPath, resolvedPath) {
+  let source = extensionPath.startsWith("<") && extensionPath.endsWith(">") ? extensionPath.slice(1, -1).split(":")[0] || "temporary" : "local", baseDir = extensionPath.startsWith("<") ? void 0 : path.dirname(resolvedPath);
+  return {
+    path: extensionPath,
+    resolvedPath,
+    sourceInfo: createSyntheticSourceInfo(extensionPath, { source, baseDir }),
+    handlers: /* @__PURE__ */ new Map(),
+    tools: /* @__PURE__ */ new Map(),
+    messageRenderers: /* @__PURE__ */ new Map(),
+    entryRenderers: /* @__PURE__ */ new Map(),
+    commands: /* @__PURE__ */ new Map(),
+    flags: /* @__PURE__ */ new Map(),
+    shortcuts: /* @__PURE__ */ new Map()
+  };
+}
+async function loadExtension(extensionPath, cwd, eventBus, runtime, cacheToken) {
+  let resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: !0 });
+  try {
+    let factory = await measureStartup(`${extensionPath} module import`, () => loadExtensionModule(resolvedPath, cacheToken));
+    if (!factory)
+      return { extension: null, error: `Extension does not export a valid factory function: ${extensionPath}` };
+    let extension = createExtension(extensionPath, resolvedPath), api = createExtensionAPI(extension, runtime, cwd, eventBus);
+    return await measureStartup(`${extensionPath} factory`, () => factory(api)), { extension, error: null };
+  } catch (err) {
+    return { extension: null, error: `Failed to load extension: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
+  let extension = createExtension(extensionPath, extensionPath), resolvedCwd = resolvePath(cwd), api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
+  return await measureStartup(`${extensionPath} factory`, () => factory(api)), extension;
+}
+async function loadExtensionsInternal(paths, cwd, eventBus, runtime, useCache = !1) {
+  let extensions = [], errors = [], cacheToken = useCache ? useExtensionCacheCwd(cwd) : void 0, resolvedCwd = cacheToken?.cwd ?? resolvePath(cwd), resolvedEventBus = eventBus ?? createEventBus(), resolvedRuntime = runtime ?? createExtensionRuntime();
+  for (let extPath of paths) {
+    let { extension, error } = await loadExtension(extPath, resolvedCwd, resolvedEventBus, resolvedRuntime, cacheToken);
+    if (error) {
+      errors.push({ path: extPath, error });
+      continue;
+    }
+    extension && extensions.push(extension);
+  }
+  return {
+    extensions,
+    errors,
+    runtime: resolvedRuntime
+  };
+}
+async function loadExtensions(paths, cwd, eventBus, runtime) {
+  return loadExtensionsInternal(paths, cwd, eventBus, runtime);
+}
+async function loadExtensionsCached(paths, cwd, eventBus, runtime) {
+  return loadExtensionsInternal(paths, cwd, eventBus, runtime, !0);
+}
+function readPiManifest(packageJsonPath) {
+  try {
+    let content = fs.readFileSync(packageJsonPath, "utf-8"), pkg = JSON.parse(content);
+    return pkg.pi && typeof pkg.pi == "object" ? pkg.pi : null;
+  } catch {
+    return null;
+  }
+}
+function isExtensionFile(name) {
+  return name.endsWith(".ts") || name.endsWith(".js");
+}
+function resolveExtensionEntries(dir) {
+  let packageJsonPath = path.join(dir, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    let manifest = readPiManifest(packageJsonPath);
+    if (manifest?.extensions?.length) {
+      let entries = [];
+      for (let extPath of manifest.extensions) {
+        let resolvedExtPath = path.resolve(dir, extPath);
+        fs.existsSync(resolvedExtPath) && entries.push(resolvedExtPath);
+      }
+      if (entries.length > 0)
+        return entries;
+    }
+  }
+  let indexTs = path.join(dir, "index.ts"), indexJs = path.join(dir, "index.js");
+  return fs.existsSync(indexTs) ? [indexTs] : fs.existsSync(indexJs) ? [indexJs] : null;
+}
+function discoverExtensionsInDir(dir) {
+  if (!fs.existsSync(dir))
+    return [];
+  let discovered = [];
+  try {
+    let entries = fs.readdirSync(dir, { withFileTypes: !0 });
+    for (let entry of entries) {
+      let entryPath = path.join(dir, entry.name);
+      if ((entry.isFile() || entry.isSymbolicLink()) && isExtensionFile(entry.name)) {
+        discovered.push(entryPath);
+        continue;
+      }
+      if (entry.isDirectory() || entry.isSymbolicLink()) {
+        let entries2 = resolveExtensionEntries(entryPath);
+        entries2 && discovered.push(...entries2);
+      }
+    }
+  } catch {
+    return [];
+  }
+  return discovered;
+}
+async function discoverAndLoadExtensions(configuredPaths, cwd, agentDir = getAgentDir(), eventBus) {
+  let resolvedCwd = resolvePath(cwd), resolvedAgentDir = resolvePath(agentDir), allPaths = [], seen = /* @__PURE__ */ new Set(), addPaths = (paths) => {
+    for (let p of paths) {
+      let resolved = path.resolve(p);
+      seen.has(resolved) || (seen.add(resolved), allPaths.push(p));
+    }
+  }, localExtDir = path.join(resolvedCwd, CONFIG_DIR_NAME, "extensions");
+  addPaths(discoverExtensionsInDir(localExtDir));
+  let globalExtDir = path.join(resolvedAgentDir, "extensions");
+  addPaths(discoverExtensionsInDir(globalExtDir));
+  for (let p of configuredPaths) {
+    let resolved = resolvePath(p, resolvedCwd, { normalizeUnicodeSpaces: !0 });
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+      let entries = resolveExtensionEntries(resolved);
+      if (entries) {
+        addPaths(entries);
+        continue;
+      }
+      addPaths(discoverExtensionsInDir(resolved));
+      continue;
+    }
+    addPaths([resolved]);
+  }
+  return loadExtensions(allPaths, resolvedCwd, eventBus);
+}
+
+// packages/coding-agent/dist/core/skills.js
+var import_ignore = __toESM(require_ignore(), 1);
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { basename, dirname as dirname2, join as join2, relative, resolve as resolve2, sep } from "path";
+var MAX_NAME_LENGTH = 64, MAX_DESCRIPTION_LENGTH = 1024, IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
+function toPosixPath(p) {
+  return p.split(sep).join("/");
+}
+function prefixIgnorePattern(line, prefix) {
+  let trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#") && !trimmed.startsWith("\\#"))
+    return null;
+  let pattern = line, negated = !1;
+  pattern.startsWith("!") ? (negated = !0, pattern = pattern.slice(1)) : pattern.startsWith("\\!") && (pattern = pattern.slice(1)), pattern.startsWith("/") && (pattern = pattern.slice(1));
+  let prefixed = prefix ? `${prefix}${pattern}` : pattern;
+  return negated ? `!${prefixed}` : prefixed;
+}
+function addIgnoreRules(ig, dir, rootDir) {
+  let relativeDir = relative(rootDir, dir), prefix = relativeDir ? `${toPosixPath(relativeDir)}/` : "";
+  for (let filename of IGNORE_FILE_NAMES) {
+    let ignorePath = join2(dir, filename);
+    if (existsSync2(ignorePath))
+      try {
+        let patterns = readFileSync2(ignorePath, "utf-8").split(/\r?\n/).map((line) => prefixIgnorePattern(line, prefix)).filter((line) => !!line);
+        patterns.length > 0 && ig.add(patterns);
+      } catch {
+      }
+  }
+}
+function validateName(name) {
+  let errors = [];
+  return name.length > MAX_NAME_LENGTH && errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`), /^[a-z0-9-]+$/.test(name) || errors.push("name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)"), (name.startsWith("-") || name.endsWith("-")) && errors.push("name must not start or end with a hyphen"), name.includes("--") && errors.push("name must not contain consecutive hyphens"), errors;
+}
+function validateDescription(description) {
+  let errors = [];
+  return !description || description.trim() === "" ? errors.push("description is required") : description.length > MAX_DESCRIPTION_LENGTH && errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`), errors;
+}
+function createSkillSourceInfo(filePath, baseDir, source) {
+  switch (source) {
+    case "user":
+      return createSyntheticSourceInfo(filePath, {
+        source: "local",
+        scope: "user",
+        baseDir
+      });
+    case "project":
+      return createSyntheticSourceInfo(filePath, {
+        source: "local",
+        scope: "project",
+        baseDir
+      });
+    case "path":
+      return createSyntheticSourceInfo(filePath, {
+        source: "local",
+        baseDir
+      });
+    default:
+      return createSyntheticSourceInfo(filePath, { source, baseDir });
+  }
+}
+function loadSkillsFromDir(options) {
+  let { dir, source } = options;
+  return loadSkillsFromDirInternal(dir, source, !0);
+}
+function loadSkillsFromDirInternal(dir, source, includeRootFiles, ignoreMatcher, rootDir) {
+  let skills = [], diagnostics = [];
+  if (!existsSync2(dir))
+    return { skills, diagnostics };
+  let root = rootDir ?? dir, ig = ignoreMatcher ?? (0, import_ignore.default)();
+  addIgnoreRules(ig, dir, root);
+  try {
+    let entries = readdirSync2(dir, { withFileTypes: !0 });
+    for (let entry of entries) {
+      if (entry.name !== "SKILL.md")
+        continue;
+      let fullPath = join2(dir, entry.name), isFile = entry.isFile();
+      if (entry.isSymbolicLink())
+        try {
+          isFile = statSync2(fullPath).isFile();
+        } catch {
+          continue;
+        }
+      let relPath = toPosixPath(relative(root, fullPath));
+      if (!isFile || ig.ignores(relPath))
+        continue;
+      let result = loadSkillFromFile(fullPath, source);
+      return result.skill && skills.push(result.skill), diagnostics.push(...result.diagnostics), { skills, diagnostics };
+    }
+    for (let entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules")
+        continue;
+      let fullPath = join2(dir, entry.name), isDirectory = entry.isDirectory(), isFile = entry.isFile();
+      if (entry.isSymbolicLink())
+        try {
+          let stats = statSync2(fullPath);
+          isDirectory = stats.isDirectory(), isFile = stats.isFile();
+        } catch {
+          continue;
+        }
+      let relPath = toPosixPath(relative(root, fullPath)), ignorePath = isDirectory ? `${relPath}/` : relPath;
+      if (ig.ignores(ignorePath))
+        continue;
+      if (isDirectory) {
+        let subResult = loadSkillsFromDirInternal(fullPath, source, !1, ig, root);
+        skills.push(...subResult.skills), diagnostics.push(...subResult.diagnostics);
+        continue;
+      }
+      if (!isFile || !includeRootFiles || !entry.name.endsWith(".md"))
+        continue;
+      let result = loadSkillFromFile(fullPath, source);
+      result.skill && skills.push(result.skill), diagnostics.push(...result.diagnostics);
+    }
+  } catch {
+  }
+  return { skills, diagnostics };
+}
+function loadSkillFromFile(filePath, source) {
+  let diagnostics = [];
+  try {
+    let rawContent = readFileSync2(filePath, "utf-8"), { frontmatter } = parseFrontmatter(rawContent), skillDir = dirname2(filePath), parentDirName = basename(skillDir), descErrors = validateDescription(frontmatter.description);
+    for (let error of descErrors)
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    let name = frontmatter.name || parentDirName, nameErrors = validateName(name);
+    for (let error of nameErrors)
+      diagnostics.push({ type: "warning", message: error, path: filePath });
+    return !frontmatter.description || frontmatter.description.trim() === "" ? { skill: null, diagnostics } : {
+      skill: {
+        name,
+        description: frontmatter.description,
+        filePath,
+        baseDir: skillDir,
+        sourceInfo: createSkillSourceInfo(filePath, skillDir, source),
+        disableModelInvocation: frontmatter["disable-model-invocation"] === !0
+      },
+      diagnostics
+    };
+  } catch (error) {
+    let message = error instanceof Error ? error.message : "failed to parse skill file";
+    return diagnostics.push({ type: "warning", message, path: filePath }), { skill: null, diagnostics };
+  }
+}
+function formatSkillsForPrompt(skills) {
+  let visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+  if (visibleSkills.length === 0)
+    return "";
+  let lines = [
+    `
+
+The following skills provide specialized instructions for specific tasks.`,
+    "Use the read tool to load a skill's file when the task matches its description.",
+    "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+    "",
+    "<available_skills>"
+  ];
+  for (let skill of visibleSkills)
+    lines.push("  <skill>"), lines.push(`    <name>${escapeXml(skill.name)}</name>`), lines.push(`    <description>${escapeXml(skill.description)}</description>`), lines.push(`    <location>${escapeXml(skill.filePath)}</location>`), lines.push("  </skill>");
+  return lines.push("</available_skills>"), lines.join(`
+`);
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function loadSkills(options) {
+  let { agentDir, skillPaths, includeDefaults } = options, resolvedCwd = resolvePath(options.cwd), resolvedAgentDir = resolvePath(agentDir ?? getAgentDir()), skillMap = /* @__PURE__ */ new Map(), realPathSet = /* @__PURE__ */ new Set(), allDiagnostics = [], collisionDiagnostics = [];
+  function addSkills(result) {
+    allDiagnostics.push(...result.diagnostics);
+    for (let skill of result.skills) {
+      let realPath = canonicalizePath(skill.filePath);
+      if (realPathSet.has(realPath))
+        continue;
+      let existing = skillMap.get(skill.name);
+      existing ? collisionDiagnostics.push({
+        type: "collision",
+        message: `name "${skill.name}" collision`,
+        path: skill.filePath,
+        collision: {
+          resourceType: "skill",
+          name: skill.name,
+          winnerPath: existing.filePath,
+          loserPath: skill.filePath
+        }
+      }) : (skillMap.set(skill.name, skill), realPathSet.add(realPath));
+    }
+  }
+  includeDefaults && (addSkills(loadSkillsFromDirInternal(join2(resolvedAgentDir, "skills"), "user", !0)), addSkills(loadSkillsFromDirInternal(resolve2(resolvedCwd, CONFIG_DIR_NAME, "skills"), "project", !0)));
+  let userSkillsDir = join2(resolvedAgentDir, "skills"), projectSkillsDir = resolve2(resolvedCwd, CONFIG_DIR_NAME, "skills"), isUnderPath = (target, root) => {
+    let normalizedRoot = resolve2(root);
+    if (target === normalizedRoot)
+      return !0;
+    let prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+    return target.startsWith(prefix);
+  }, getSource = (resolvedPath) => {
+    if (!includeDefaults) {
+      if (isUnderPath(resolvedPath, userSkillsDir))
+        return "user";
+      if (isUnderPath(resolvedPath, projectSkillsDir))
+        return "project";
+    }
+    return "path";
+  };
+  for (let rawPath of skillPaths) {
+    let resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: !0 });
+    if (!existsSync2(resolvedPath)) {
+      allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
+      continue;
+    }
+    try {
+      let stats = statSync2(resolvedPath), source = getSource(resolvedPath);
+      if (stats.isDirectory())
+        addSkills(loadSkillsFromDirInternal(resolvedPath, source, !0));
+      else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+        let result = loadSkillFromFile(resolvedPath, source);
+        result.skill ? addSkills({ skills: [result.skill], diagnostics: result.diagnostics }) : allDiagnostics.push(...result.diagnostics);
+      } else
+        allDiagnostics.push({ type: "warning", message: "skill path is not a markdown file", path: resolvedPath });
+    } catch (error) {
+      let message = error instanceof Error ? error.message : "failed to read skill path";
+      allDiagnostics.push({ type: "warning", message, path: resolvedPath });
+    }
+  }
+  return {
+    skills: Array.from(skillMap.values()),
+    diagnostics: [...allDiagnostics, ...collisionDiagnostics]
+  };
+}
+
+// packages/coding-agent/dist/core/resource-loader.js
+import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync4, statSync as statSync4 } from "node:fs";
+import { dirname as dirname4, join as join4, resolve as resolve4, sep as sep3 } from "node:path";
+import chalk from "chalk";
+
+// packages/coding-agent/dist/core/prompt-templates.js
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { basename as basename2, dirname as dirname3, join as join3, resolve as resolve3, sep as sep2 } from "path";
+function parseCommandArgs(argsString) {
+  let args = [], current = "", inQuote = null;
+  for (let i = 0; i < argsString.length; i++) {
+    let char = argsString[i];
+    inQuote ? char === inQuote ? inQuote = null : current += char : char === '"' || char === "'" ? inQuote = char : /\s/.test(char) ? current && (args.push(current), current = "") : current += char;
+  }
+  return current && args.push(current), args;
+}
+function substituteArgs(content, args) {
+  let allArgs = args.join(" ");
+  return content.replace(/\$\{(\d+):-([^}]*)\}|\$\{@:(\d+)(?::(\d+))?\}|\$(ARGUMENTS|@|\d+)/g, (_match, defaultNum, defaultValue, sliceStart, sliceLength, simple) => {
+    if (defaultNum) {
+      let index2 = parseInt(defaultNum, 10) - 1, value = args[index2];
+      return value || defaultValue;
+    }
+    if (sliceStart) {
+      let start = parseInt(sliceStart, 10) - 1;
+      if (start < 0 && (start = 0), sliceLength) {
+        let length = parseInt(sliceLength, 10);
+        return args.slice(start, start + length).join(" ");
+      }
+      return args.slice(start).join(" ");
+    }
+    if (simple === "ARGUMENTS" || simple === "@")
+      return allArgs;
+    let index = parseInt(simple, 10) - 1;
+    return args[index] ?? "";
+  });
+}
+function loadTemplateFromFile(filePath, sourceInfo) {
+  try {
+    let rawContent = readFileSync3(filePath, "utf-8"), { frontmatter, body } = parseFrontmatter(rawContent), name = basename2(filePath).replace(/\.md$/, ""), description = frontmatter.description || "";
+    if (!description) {
+      let firstLine = body.split(`
+`).find((line) => line.trim());
+      firstLine && (description = firstLine.slice(0, 60), firstLine.length > 60 && (description += "..."));
+    }
+    return {
+      name,
+      description,
+      ...frontmatter["argument-hint"] && { argumentHint: frontmatter["argument-hint"] },
+      content: body,
+      sourceInfo,
+      filePath
+    };
+  } catch {
+    return null;
+  }
+}
+function loadTemplatesFromDir(dir, getSourceInfo) {
+  let templates = [];
+  if (!existsSync3(dir))
+    return templates;
+  try {
+    let entries = readdirSync3(dir, { withFileTypes: !0 });
+    for (let entry of entries) {
+      let fullPath = join3(dir, entry.name), isFile = entry.isFile();
+      if (entry.isSymbolicLink())
+        try {
+          isFile = statSync3(fullPath).isFile();
+        } catch {
+          continue;
+        }
+      if (isFile && entry.name.endsWith(".md")) {
+        let template = loadTemplateFromFile(fullPath, getSourceInfo(fullPath));
+        template && templates.push(template);
+      }
+    }
+  } catch {
+    return templates;
+  }
+  return templates;
+}
+function loadPromptTemplates(options) {
+  let resolvedCwd = resolvePath(options.cwd), resolvedAgentDir = resolvePath(options.agentDir), promptPaths = options.promptPaths, includeDefaults = options.includeDefaults, templates = [], globalPromptsDir = join3(resolvedAgentDir, "prompts"), projectPromptsDir = resolve3(resolvedCwd, CONFIG_DIR_NAME, "prompts"), isUnderPath = (target, root) => {
+    let normalizedRoot = resolve3(root);
+    if (target === normalizedRoot)
+      return !0;
+    let prefix = normalizedRoot.endsWith(sep2) ? normalizedRoot : `${normalizedRoot}${sep2}`;
+    return target.startsWith(prefix);
+  }, getSourceInfo = (resolvedPath) => isUnderPath(resolvedPath, globalPromptsDir) ? createSyntheticSourceInfo(resolvedPath, {
+    source: "local",
+    scope: "user",
+    baseDir: globalPromptsDir
+  }) : isUnderPath(resolvedPath, projectPromptsDir) ? createSyntheticSourceInfo(resolvedPath, {
+    source: "local",
+    scope: "project",
+    baseDir: projectPromptsDir
+  }) : createSyntheticSourceInfo(resolvedPath, {
+    source: "local",
+    baseDir: statSync3(resolvedPath).isDirectory() ? resolvedPath : dirname3(resolvedPath)
+  });
+  includeDefaults && (templates.push(...loadTemplatesFromDir(globalPromptsDir, getSourceInfo)), templates.push(...loadTemplatesFromDir(projectPromptsDir, getSourceInfo)));
+  for (let rawPath of promptPaths) {
+    let resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: !0 });
+    if (existsSync3(resolvedPath))
+      try {
+        let stats = statSync3(resolvedPath);
+        if (stats.isDirectory())
+          templates.push(...loadTemplatesFromDir(resolvedPath, getSourceInfo));
+        else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+          let template = loadTemplateFromFile(resolvedPath, getSourceInfo(resolvedPath));
+          template && templates.push(template);
+        }
+      } catch {
+      }
+  }
+  return templates;
+}
+function expandPromptTemplate(text, templates) {
+  if (!text.startsWith("/"))
+    return text;
+  let match = text.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/);
+  if (!match)
+    return text;
+  let templateName = match[1], argsString = match[2] ?? "", template = templates.find((t) => t.name === templateName);
+  if (template) {
+    let args = parseCommandArgs(argsString);
+    return substituteArgs(template.content, args);
+  }
+  return text;
+}
+
+// packages/coding-agent/dist/core/resource-loader.js
+function inlineExtensionPath(input, index) {
+  return `<inline:${typeof input != "function" ? input.name : index + 1}>`;
+}
+function resolvePromptInput(input, description) {
+  if (input) {
+    if (existsSync4(input))
+      try {
+        return readFileSync4(input, "utf-8");
+      } catch (error) {
+        return console.error(chalk.yellow(`Warning: Could not read ${description} file ${input}: ${error}`)), input;
+      }
+    return input;
+  }
+}
+function loadContextFileFromDir(dir) {
+  let candidates = ["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"];
+  for (let filename of candidates) {
+    let filePath = join4(dir, filename);
+    if (existsSync4(filePath))
+      try {
+        return {
+          path: filePath,
+          content: readFileSync4(filePath, "utf-8")
+        };
+      } catch (error) {
+        console.error(chalk.yellow(`Warning: Could not read ${filePath}: ${error}`));
+      }
+  }
+  return null;
+}
+function loadProjectContextFiles(options) {
+  let resolvedCwd = resolvePath(options.cwd), resolvedAgentDir = resolvePath(options.agentDir), contextFiles = [], seenPaths = /* @__PURE__ */ new Set(), userContexts = options.settingsManager ? loadSelectedUserInstructions({ agentDir: resolvedAgentDir, settingsManager: options.settingsManager }) : [getGlobalInstructionsPath(resolvedAgentDir)].map((path2) => loadContextFileFromDir(dirname4(path2))).filter((file) => file !== null);
+  for (let userContext of userContexts)
+    contextFiles.push(userContext), seenPaths.add(userContext.path);
+  let ancestorContextFiles = [], currentDir = resolvedCwd;
+  for (; ; ) {
+    let contextFile = loadContextFileFromDir(currentDir);
+    contextFile && !seenPaths.has(contextFile.path) && (ancestorContextFiles.unshift(contextFile), seenPaths.add(contextFile.path));
+    let parentDir = dirname4(currentDir);
+    if (parentDir === currentDir)
+      break;
+    currentDir = parentDir;
+  }
+  return contextFiles.push(...ancestorContextFiles), contextFiles;
+}
+var DefaultResourceLoader = class {
+  cwd;
+  agentDir;
+  settingsManager;
+  eventBus;
+  packageManager;
+  additionalExtensionPaths;
+  additionalSkillPaths;
+  additionalPromptTemplatePaths;
+  additionalThemePaths;
+  extensionFactories;
+  noExtensions;
+  noSkills;
+  noPromptTemplates;
+  noThemes;
+  noContextFiles;
+  systemPromptSource;
+  appendSystemPromptSource;
+  extensionsOverride;
+  skillsOverride;
+  promptsOverride;
+  themesOverride;
+  agentsFilesOverride;
+  systemPromptOverride;
+  appendSystemPromptOverride;
+  extensionsResult;
+  skills;
+  skillDiagnostics;
+  prompts;
+  promptDiagnostics;
+  themes;
+  themeDiagnostics;
+  agentsFiles;
+  systemPrompt;
+  appendSystemPrompt;
+  lastSkillPaths;
+  extensionSkillSourceInfos;
+  extensionPromptSourceInfos;
+  extensionThemeSourceInfos;
+  lastPromptPaths;
+  lastThemePaths;
+  loaded;
+  constructor(options) {
+    this.cwd = resolvePath(options.cwd), this.agentDir = resolvePath(options.agentDir), this.settingsManager = options.settingsManager ?? SettingsManager.create(this.cwd, this.agentDir), this.eventBus = options.eventBus ?? createEventBus(), this.packageManager = new DefaultPackageManager({
+      cwd: this.cwd,
+      agentDir: this.agentDir,
+      settingsManager: this.settingsManager
+    }), this.additionalExtensionPaths = options.additionalExtensionPaths ?? [], this.additionalSkillPaths = options.additionalSkillPaths ?? [], this.additionalPromptTemplatePaths = options.additionalPromptTemplatePaths ?? [], this.additionalThemePaths = options.additionalThemePaths ?? [], this.extensionFactories = options.extensionFactories ?? [], this.noExtensions = options.noExtensions ?? !1, this.noSkills = options.noSkills ?? !1, this.noPromptTemplates = options.noPromptTemplates ?? !1, this.noThemes = options.noThemes ?? !1, this.noContextFiles = options.noContextFiles ?? !1, this.systemPromptSource = options.systemPrompt, this.appendSystemPromptSource = options.appendSystemPrompt, this.extensionsOverride = options.extensionsOverride, this.skillsOverride = options.skillsOverride, this.promptsOverride = options.promptsOverride, this.themesOverride = options.themesOverride, this.agentsFilesOverride = options.agentsFilesOverride, this.systemPromptOverride = options.systemPromptOverride, this.appendSystemPromptOverride = options.appendSystemPromptOverride, this.extensionsResult = { extensions: [], errors: [], runtime: createExtensionRuntime() }, this.skills = [], this.skillDiagnostics = [], this.prompts = [], this.promptDiagnostics = [], this.themes = [], this.themeDiagnostics = [], this.agentsFiles = [], this.appendSystemPrompt = [], this.lastSkillPaths = [], this.extensionSkillSourceInfos = /* @__PURE__ */ new Map(), this.extensionPromptSourceInfos = /* @__PURE__ */ new Map(), this.extensionThemeSourceInfos = /* @__PURE__ */ new Map(), this.lastPromptPaths = [], this.lastThemePaths = [], this.loaded = !1;
+  }
+  getExtensions() {
+    return this.extensionsResult;
+  }
+  getSkills() {
+    return { skills: this.skills, diagnostics: this.skillDiagnostics };
+  }
+  getPrompts() {
+    return { prompts: this.prompts, diagnostics: this.promptDiagnostics };
+  }
+  getThemes() {
+    return { themes: this.themes, diagnostics: this.themeDiagnostics };
+  }
+  getAgentsFiles() {
+    return { agentsFiles: this.agentsFiles };
+  }
+  contextFilesEnabled() {
+    return !this.noContextFiles;
+  }
+  getSystemPrompt() {
+    return this.systemPrompt;
+  }
+  getAppendSystemPrompt() {
+    return this.appendSystemPrompt;
+  }
+  async attachInlineExtensions(factories) {
+    let loaded = new Set(this.extensionsResult.extensions.map((extension) => extension.path)), pending = factories.filter((factory, index) => {
+      let path2 = inlineExtensionPath(factory, this.extensionFactories.length + index);
+      return !loaded.has(path2);
+    });
+    if (pending.length === 0)
+      return { extensions: [], errors: [], runtime: this.extensionsResult.runtime };
+    let attached = await this.loadExtensionFactories(this.extensionsResult.runtime, pending);
+    return this.extensionFactories.push(...pending), this.extensionsResult.extensions.push(...attached.extensions), this.extensionsResult.errors.push(...attached.errors), this.addExtensionConflictDiagnostics(this.extensionsResult), {
+      extensions: attached.extensions,
+      errors: attached.errors,
+      runtime: this.extensionsResult.runtime
+    };
+  }
+  extendResources(paths) {
+    let skillPaths = this.normalizeExtensionPaths(paths.skillPaths ?? []), promptPaths = this.normalizeExtensionPaths(paths.promptPaths ?? []), themePaths = this.normalizeExtensionPaths(paths.themePaths ?? []);
+    for (let entry of skillPaths)
+      this.extensionSkillSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+    for (let entry of promptPaths)
+      this.extensionPromptSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+    for (let entry of themePaths)
+      this.extensionThemeSourceInfos.set(entry.path, createSourceInfo(entry.path, entry.metadata));
+    skillPaths.length > 0 && (this.lastSkillPaths = this.mergePaths(this.lastSkillPaths, skillPaths.map((entry) => entry.path)), this.updateSkillsFromPaths(this.lastSkillPaths)), promptPaths.length > 0 && (this.lastPromptPaths = this.mergePaths(this.lastPromptPaths, promptPaths.map((entry) => entry.path)), this.updatePromptsFromPaths(this.lastPromptPaths)), themePaths.length > 0 && (this.lastThemePaths = this.mergePaths(this.lastThemePaths, themePaths.map((entry) => entry.path)), this.updateThemesFromPaths(this.lastThemePaths));
+  }
+  resolveOnMissing(skipMissingPackageInstall) {
+    if (skipMissingPackageInstall)
+      return async () => "skip";
+  }
+  async loadProjectTrustExtensions(options) {
+    return this.settingsManager.setProjectTrusted(!1), await this.settingsManager.reload(), this.loadCurrentExtensionSet({
+      includeInlineFactories: !0,
+      skipMissingPackageInstall: options?.skipMissingPackageInstall
+    });
+  }
+  async reload(options) {
+    resetTimings("extensions"), this.loaded && clearExtensionCache();
+    let preTrustExtensions;
+    if (options?.resolveProjectTrust) {
+      preTrustExtensions = await this.loadProjectTrustExtensions(options);
+      let projectTrusted = await options.resolveProjectTrust({ extensionsResult: preTrustExtensions });
+      this.settingsManager.setProjectTrusted(projectTrusted);
+    }
+    await this.settingsManager.reload();
+    let resolvedPaths = await this.packageManager.resolve(this.resolveOnMissing(options?.skipMissingPackageInstall)), cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
+      temporary: !0
+    }), metadataByPath = /* @__PURE__ */ new Map();
+    this.extensionSkillSourceInfos = /* @__PURE__ */ new Map(), this.extensionPromptSourceInfos = /* @__PURE__ */ new Map(), this.extensionThemeSourceInfos = /* @__PURE__ */ new Map();
+    let getEnabledResources = (resources) => {
+      for (let r of resources)
+        metadataByPath.has(r.path) || metadataByPath.set(r.path, r.metadata);
+      return resources.filter((r) => r.enabled);
+    }, getEnabledPaths = (resources) => getEnabledResources(resources).map((r) => r.path), enabledExtensions = getEnabledPaths(resolvedPaths.extensions), enabledSkillResources = getEnabledResources(resolvedPaths.skills), enabledPrompts = getEnabledPaths(resolvedPaths.prompts), enabledThemes = getEnabledPaths(resolvedPaths.themes), enabledSkills = enabledSkillResources.map((resource) => this.mapSkillPath(resource, metadataByPath));
+    for (let r of cliExtensionPaths.extensions)
+      metadataByPath.has(r.path) || metadataByPath.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
+    for (let r of cliExtensionPaths.skills)
+      metadataByPath.has(r.path) || metadataByPath.set(r.path, { source: "cli", scope: "temporary", origin: "top-level" });
+    let cliEnabledExtensions = getEnabledPaths(cliExtensionPaths.extensions), cliEnabledSkills = getEnabledPaths(cliExtensionPaths.skills), cliEnabledPrompts = getEnabledPaths(cliExtensionPaths.prompts), cliEnabledThemes = getEnabledPaths(cliExtensionPaths.themes), extensionPaths = this.noExtensions ? cliEnabledExtensions : this.mergePaths(cliEnabledExtensions, enabledExtensions), extensionsResult = await this.loadFinalExtensionSet(extensionPaths, preTrustExtensions);
+    for (let p of this.additionalExtensionPaths)
+      if (isLocalPath(p)) {
+        let resolved = this.resolveResourcePath(p);
+        existsSync4(resolved) || extensionsResult.errors.push({ path: resolved, error: `Extension path does not exist: ${resolved}` });
+      }
+    this.extensionsResult = this.extensionsOverride ? this.extensionsOverride(extensionsResult) : extensionsResult, this.applyExtensionSourceInfo(this.extensionsResult.extensions, metadataByPath);
+    let skillPaths = this.noSkills ? this.mergePaths(cliEnabledSkills, this.additionalSkillPaths) : this.mergePaths([...cliEnabledSkills, ...enabledSkills], this.additionalSkillPaths);
+    this.lastSkillPaths = skillPaths, this.updateSkillsFromPaths(skillPaths, metadataByPath);
+    for (let p of this.additionalSkillPaths)
+      if (isLocalPath(p)) {
+        let resolved = this.resolveResourcePath(p);
+        !existsSync4(resolved) && !this.skillDiagnostics.some((d) => d.path === resolved) && this.skillDiagnostics.push({ type: "error", message: "Skill path does not exist", path: resolved });
+      }
+    let promptPaths = this.noPromptTemplates ? this.mergePaths(cliEnabledPrompts, this.additionalPromptTemplatePaths) : this.mergePaths([...cliEnabledPrompts, ...enabledPrompts], this.additionalPromptTemplatePaths);
+    this.lastPromptPaths = promptPaths, this.updatePromptsFromPaths(promptPaths, metadataByPath);
+    for (let p of this.additionalPromptTemplatePaths)
+      if (isLocalPath(p)) {
+        let resolved = this.resolveResourcePath(p);
+        !existsSync4(resolved) && !this.promptDiagnostics.some((d) => d.path === resolved) && this.promptDiagnostics.push({
+          type: "error",
+          message: "Prompt template path does not exist",
+          path: resolved
+        });
+      }
+    let themePaths = this.noThemes ? this.mergePaths(cliEnabledThemes, this.additionalThemePaths) : this.mergePaths([...cliEnabledThemes, ...enabledThemes], this.additionalThemePaths);
+    this.lastThemePaths = themePaths, this.updateThemesFromPaths(themePaths, metadataByPath);
+    for (let p of this.additionalThemePaths) {
+      let resolved = this.resolveResourcePath(p);
+      !existsSync4(resolved) && !this.themeDiagnostics.some((d) => d.path === resolved) && this.themeDiagnostics.push({ type: "error", message: "Theme path does not exist", path: resolved });
+    }
+    let agentsFiles = {
+      agentsFiles: this.noContextFiles ? [] : loadProjectContextFiles({
+        cwd: this.cwd,
+        agentDir: this.agentDir,
+        settingsManager: this.settingsManager
+      })
+    }, resolvedAgentsFiles = this.agentsFilesOverride ? this.agentsFilesOverride(agentsFiles) : agentsFiles;
+    this.agentsFiles = resolvedAgentsFiles.agentsFiles;
+    let baseSystemPrompt = resolvePromptInput(this.systemPromptSource ?? this.discoverSystemPromptFile(), "system prompt");
+    this.systemPrompt = this.systemPromptOverride ? this.systemPromptOverride(baseSystemPrompt) : baseSystemPrompt;
+    let baseAppend = (this.appendSystemPromptSource ?? (this.discoverAppendSystemPromptFile() ? [this.discoverAppendSystemPromptFile()] : [])).map((s) => resolvePromptInput(s, "append system prompt")).filter((s) => s !== void 0);
+    this.appendSystemPrompt = this.appendSystemPromptOverride ? this.appendSystemPromptOverride(baseAppend) : baseAppend, this.loaded = !0;
+  }
+  async loadCurrentExtensionSet(options) {
+    let resolvedPaths = await this.packageManager.resolve(this.resolveOnMissing(options.skipMissingPackageInstall)), cliExtensionPaths = await this.packageManager.resolveExtensionSources(this.additionalExtensionPaths, {
+      temporary: !0
+    }), enabledExtensions = resolvedPaths.extensions.filter((r) => r.enabled).map((r) => r.path), cliEnabledExtensions = cliExtensionPaths.extensions.filter((r) => r.enabled).map((r) => r.path), extensionPaths = this.noExtensions ? cliEnabledExtensions : this.mergePaths(cliEnabledExtensions, enabledExtensions), extensionsResult = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus);
+    if (!options.includeInlineFactories)
+      return extensionsResult;
+    let inlineExtensions = await this.loadExtensionFactories(extensionsResult.runtime);
+    return extensionsResult.extensions.push(...inlineExtensions.extensions), extensionsResult.errors.push(...inlineExtensions.errors), extensionsResult;
+  }
+  resolveExtensionLoadPath(path2) {
+    return resolvePath(path2, this.cwd, { normalizeUnicodeSpaces: !0 });
+  }
+  async loadFinalExtensionSet(extensionPaths, preTrustExtensions) {
+    if (!preTrustExtensions) {
+      let extensionsResult2 = await loadExtensionsCached(extensionPaths, this.cwd, this.eventBus), inlineExtensions2 = await this.loadExtensionFactories(extensionsResult2.runtime);
+      return extensionsResult2.extensions.push(...inlineExtensions2.extensions), extensionsResult2.errors.push(...inlineExtensions2.errors), this.addExtensionConflictDiagnostics(extensionsResult2), extensionsResult2;
+    }
+    let preloadedByPath = new Map(preTrustExtensions.extensions.filter((extension) => !extension.path.startsWith("<inline:")).map((extension) => [extension.resolvedPath, extension])), failedPreloadPaths = new Set(preTrustExtensions.errors.map((error) => this.resolveExtensionLoadPath(error.path))), remainingPaths = extensionPaths.filter((path2) => {
+      let resolvedPath = this.resolveExtensionLoadPath(path2);
+      return !preloadedByPath.has(resolvedPath) && !failedPreloadPaths.has(resolvedPath);
+    }), remainingExtensions = await loadExtensionsCached(remainingPaths, this.cwd, this.eventBus, preTrustExtensions.runtime), loadedByPath = new Map(preloadedByPath);
+    for (let extension of remainingExtensions.extensions)
+      loadedByPath.set(extension.resolvedPath, extension);
+    let inlineExtensions = preTrustExtensions.extensions.filter((extension) => extension.path.startsWith("<inline:")), orderedExtensions = extensionPaths.map((path2) => loadedByPath.get(this.resolveExtensionLoadPath(path2))).filter((extension) => extension !== void 0);
+    orderedExtensions.push(...inlineExtensions);
+    let extensionsResult = {
+      extensions: orderedExtensions,
+      errors: [...preTrustExtensions.errors, ...remainingExtensions.errors],
+      runtime: preTrustExtensions.runtime
+    };
+    return this.addExtensionConflictDiagnostics(extensionsResult), extensionsResult;
+  }
+  addExtensionConflictDiagnostics(extensionsResult) {
+    let conflicts = this.detectExtensionConflicts(extensionsResult.extensions);
+    for (let conflict of conflicts)
+      extensionsResult.errors.push({ path: conflict.path, error: conflict.message });
+  }
+  mapSkillPath(resource, metadataByPath) {
+    if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package")
+      return resource.path;
+    try {
+      if (!statSync4(resource.path).isDirectory())
+        return resource.path;
+    } catch {
+      return resource.path;
+    }
+    let skillFile = join4(resource.path, "SKILL.md");
+    return existsSync4(skillFile) ? (metadataByPath.has(skillFile) || metadataByPath.set(skillFile, resource.metadata), skillFile) : resource.path;
+  }
+  normalizeExtensionPaths(entries) {
+    return entries.map((entry) => {
+      let metadata = entry.metadata.baseDir ? { ...entry.metadata, baseDir: this.resolveResourcePath(entry.metadata.baseDir) } : entry.metadata;
+      return {
+        path: this.resolveResourcePath(entry.path),
+        metadata
+      };
+    });
+  }
+  updateSkillsFromPaths(skillPaths, metadataByPath) {
+    let skillsResult;
+    this.noSkills && skillPaths.length === 0 ? skillsResult = { skills: [], diagnostics: [] } : skillsResult = loadSkills({
+      cwd: this.cwd,
+      agentDir: this.agentDir,
+      skillPaths,
+      includeDefaults: !1
+    });
+    let resolvedSkills = this.skillsOverride ? this.skillsOverride(skillsResult) : skillsResult;
+    this.skills = resolvedSkills.skills.map((skill) => ({
+      ...skill,
+      sourceInfo: this.findSourceInfoForPath(skill.filePath, this.extensionSkillSourceInfos, metadataByPath) ?? skill.sourceInfo ?? this.getDefaultSourceInfoForPath(skill.filePath)
+    })), this.skillDiagnostics = resolvedSkills.diagnostics;
+  }
+  updatePromptsFromPaths(promptPaths, metadataByPath) {
+    let promptsResult;
+    if (this.noPromptTemplates && promptPaths.length === 0)
+      promptsResult = { prompts: [], diagnostics: [] };
+    else {
+      let allPrompts = loadPromptTemplates({
+        cwd: this.cwd,
+        agentDir: this.agentDir,
+        promptPaths,
+        includeDefaults: !1
+      });
+      promptsResult = this.dedupePrompts(allPrompts);
+    }
+    let resolvedPrompts = this.promptsOverride ? this.promptsOverride(promptsResult) : promptsResult;
+    this.prompts = resolvedPrompts.prompts.map((prompt) => ({
+      ...prompt,
+      sourceInfo: this.findSourceInfoForPath(prompt.filePath, this.extensionPromptSourceInfos, metadataByPath) ?? prompt.sourceInfo ?? this.getDefaultSourceInfoForPath(prompt.filePath)
+    })), this.promptDiagnostics = resolvedPrompts.diagnostics;
+  }
+  updateThemesFromPaths(themePaths, metadataByPath) {
+    let themesResult;
+    if (this.noThemes && themePaths.length === 0)
+      themesResult = { themes: [], diagnostics: [] };
+    else {
+      let loaded = this.loadThemes(themePaths, !1), deduped = this.dedupeThemes(loaded.themes);
+      themesResult = { themes: deduped.themes, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
+    }
+    let resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
+    this.themes = resolvedThemes.themes.map((theme) => {
+      let sourcePath = theme.sourcePath;
+      return theme.sourceInfo = sourcePath ? this.findSourceInfoForPath(sourcePath, this.extensionThemeSourceInfos, metadataByPath) ?? theme.sourceInfo ?? this.getDefaultSourceInfoForPath(sourcePath) : theme.sourceInfo, theme;
+    }), this.themeDiagnostics = resolvedThemes.diagnostics;
+  }
+  applyExtensionSourceInfo(extensions, metadataByPath) {
+    for (let extension of extensions) {
+      extension.sourceInfo = this.findSourceInfoForPath(extension.path, void 0, metadataByPath) ?? this.getDefaultSourceInfoForPath(extension.path);
+      for (let command of extension.commands.values())
+        command.sourceInfo = extension.sourceInfo;
+      for (let tool of extension.tools.values())
+        tool.sourceInfo = extension.sourceInfo;
+    }
+  }
+  findSourceInfoForPath(resourcePath, extraSourceInfos, metadataByPath) {
+    if (!resourcePath)
+      return;
+    if (resourcePath.startsWith("<"))
+      return this.getDefaultSourceInfoForPath(resourcePath);
+    let normalizedResourcePath = resolve4(resourcePath);
+    if (extraSourceInfos)
+      for (let [sourcePath, sourceInfo] of extraSourceInfos.entries()) {
+        let normalizedSourcePath = resolve4(sourcePath);
+        if (normalizedResourcePath === normalizedSourcePath || normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep3}`))
+          return { ...sourceInfo, path: resourcePath };
+      }
+    if (metadataByPath) {
+      let exact = metadataByPath.get(normalizedResourcePath) ?? metadataByPath.get(resourcePath);
+      if (exact)
+        return createSourceInfo(resourcePath, exact);
+      for (let [sourcePath, metadata] of metadataByPath.entries()) {
+        let normalizedSourcePath = resolve4(sourcePath);
+        if (normalizedResourcePath === normalizedSourcePath || normalizedResourcePath.startsWith(`${normalizedSourcePath}${sep3}`))
+          return createSourceInfo(resourcePath, metadata);
+      }
+    }
+  }
+  getDefaultSourceInfoForPath(filePath) {
+    if (filePath.startsWith("<") && filePath.endsWith(">"))
+      return {
+        path: filePath,
+        source: filePath.slice(1, -1).split(":")[0] || "temporary",
+        scope: "temporary",
+        origin: "top-level"
+      };
+    let normalizedPath = resolve4(filePath), agentRoots = [
+      join4(this.agentDir, "skills"),
+      join4(this.agentDir, "prompts"),
+      join4(this.agentDir, "themes"),
+      join4(this.agentDir, "extensions")
+    ], projectRoots = [
+      join4(this.cwd, CONFIG_DIR_NAME, "skills"),
+      join4(this.cwd, CONFIG_DIR_NAME, "prompts"),
+      join4(this.cwd, CONFIG_DIR_NAME, "themes"),
+      join4(this.cwd, CONFIG_DIR_NAME, "extensions")
+    ];
+    for (let root of agentRoots)
+      if (this.isUnderPath(normalizedPath, root))
+        return { path: filePath, source: "local", scope: "user", origin: "top-level", baseDir: root };
+    for (let root of projectRoots)
+      if (this.isUnderPath(normalizedPath, root))
+        return { path: filePath, source: "local", scope: "project", origin: "top-level", baseDir: root };
+    return {
+      path: filePath,
+      source: "local",
+      scope: "temporary",
+      origin: "top-level",
+      baseDir: statSync4(normalizedPath).isDirectory() ? normalizedPath : resolve4(normalizedPath, "..")
+    };
+  }
+  mergePaths(primary, additional) {
+    let merged = [], seen = /* @__PURE__ */ new Set();
+    for (let p of [...primary, ...additional]) {
+      let resolved = this.resolveResourcePath(p), canonicalPath = canonicalizePath(resolved);
+      seen.has(canonicalPath) || (seen.add(canonicalPath), merged.push(resolved));
+    }
+    return merged;
+  }
+  resolveResourcePath(p) {
+    return resolvePath(p, this.cwd, { trim: !0 });
+  }
+  loadThemes(paths, includeDefaults = !0) {
+    let themes = [], diagnostics = [];
+    if (includeDefaults) {
+      let defaultDirs = [join4(this.agentDir, "themes"), join4(this.cwd, CONFIG_DIR_NAME, "themes")];
+      for (let dir of defaultDirs)
+        this.loadThemesFromDir(dir, themes, diagnostics);
+    }
+    for (let p of paths) {
+      let resolved = this.resolveResourcePath(p);
+      if (!existsSync4(resolved)) {
+        diagnostics.push({ type: "warning", message: "theme path does not exist", path: resolved });
+        continue;
+      }
+      try {
+        let stats = statSync4(resolved);
+        stats.isDirectory() ? this.loadThemesFromDir(resolved, themes, diagnostics) : stats.isFile() && resolved.endsWith(".json") ? this.loadThemeFromFile(resolved, themes, diagnostics) : diagnostics.push({ type: "warning", message: "theme path is not a json file", path: resolved });
+      } catch (error) {
+        let message = error instanceof Error ? error.message : "failed to read theme path";
+        diagnostics.push({ type: "warning", message, path: resolved });
+      }
+    }
+    return { themes, diagnostics };
+  }
+  loadThemesFromDir(dir, themes, diagnostics) {
+    if (existsSync4(dir))
+      try {
+        let entries = readdirSync4(dir, { withFileTypes: !0 });
+        for (let entry of entries) {
+          let isFile = entry.isFile();
+          if (entry.isSymbolicLink())
+            try {
+              isFile = statSync4(join4(dir, entry.name)).isFile();
+            } catch {
+              continue;
+            }
+          isFile && entry.name.endsWith(".json") && this.loadThemeFromFile(join4(dir, entry.name), themes, diagnostics);
+        }
+      } catch (error) {
+        let message = error instanceof Error ? error.message : "failed to read theme directory";
+        diagnostics.push({ type: "warning", message, path: dir });
+      }
+  }
+  loadThemeFromFile(filePath, themes, diagnostics) {
+    try {
+      themes.push(loadThemeFromPath(filePath));
+    } catch (error) {
+      let message = error instanceof Error ? error.message : "failed to load theme";
+      diagnostics.push({ type: "warning", message, path: filePath });
+    }
+  }
+  async loadExtensionFactories(runtime, factories = this.extensionFactories) {
+    let extensions = [], errors = [];
+    for (let [index, input] of factories.entries()) {
+      let factory = typeof input != "function" ? input.factory : input, extensionPath = inlineExtensionPath(input, index);
+      try {
+        let extension = await loadExtensionFromFactory(factory, this.cwd, this.eventBus, runtime, extensionPath);
+        extensions.push(extension);
+      } catch (error) {
+        let message = error instanceof Error ? error.message : "failed to load extension";
+        errors.push({ path: extensionPath, error: message });
+      }
+    }
+    return { extensions, errors };
+  }
+  dedupePrompts(prompts) {
+    let seen = /* @__PURE__ */ new Map(), diagnostics = [];
+    for (let prompt of prompts) {
+      let existing = seen.get(prompt.name);
+      existing ? diagnostics.push({
+        type: "collision",
+        message: `name "/${prompt.name}" collision`,
+        path: prompt.filePath,
+        collision: {
+          resourceType: "prompt",
+          name: prompt.name,
+          winnerPath: existing.filePath,
+          loserPath: prompt.filePath
+        }
+      }) : seen.set(prompt.name, prompt);
+    }
+    return { prompts: Array.from(seen.values()), diagnostics };
+  }
+  dedupeThemes(themes) {
+    let seen = /* @__PURE__ */ new Map(), diagnostics = [];
+    for (let t of themes) {
+      let name = t.name ?? "unnamed", existing = seen.get(name);
+      existing ? diagnostics.push({
+        type: "collision",
+        message: `name "${name}" collision`,
+        path: t.sourcePath,
+        collision: {
+          resourceType: "theme",
+          name,
+          winnerPath: existing.sourcePath ?? "<builtin>",
+          loserPath: t.sourcePath ?? "<builtin>"
+        }
+      }) : seen.set(name, t);
+    }
+    return { themes: Array.from(seen.values()), diagnostics };
+  }
+  discoverSystemPromptFile() {
+    let projectPath = join4(this.cwd, CONFIG_DIR_NAME, "SYSTEM.md");
+    if (this.settingsManager.isProjectTrusted() && existsSync4(projectPath))
+      return projectPath;
+    let globalPath = join4(this.agentDir, "SYSTEM.md");
+    if (existsSync4(globalPath))
+      return globalPath;
+  }
+  discoverAppendSystemPromptFile() {
+    let projectPath = join4(this.cwd, CONFIG_DIR_NAME, "APPEND_SYSTEM.md");
+    if (this.settingsManager.isProjectTrusted() && existsSync4(projectPath))
+      return projectPath;
+    let globalPath = join4(this.agentDir, "APPEND_SYSTEM.md");
+    if (existsSync4(globalPath))
+      return globalPath;
+  }
+  isUnderPath(target, root) {
+    let normalizedRoot = resolve4(root);
+    if (target === normalizedRoot)
+      return !0;
+    let prefix = normalizedRoot.endsWith(sep3) ? normalizedRoot : `${normalizedRoot}${sep3}`;
+    return target.startsWith(prefix);
+  }
+  detectExtensionConflicts(extensions) {
+    let conflicts = [], toolOwners = /* @__PURE__ */ new Map(), flagOwners = /* @__PURE__ */ new Map();
+    for (let ext of extensions) {
+      for (let toolName of ext.tools.keys()) {
+        let existingOwner = toolOwners.get(toolName);
+        existingOwner && existingOwner !== ext.path ? conflicts.push({
+          path: ext.path,
+          message: `Tool "${toolName}" conflicts with ${existingOwner}`
+        }) : toolOwners.set(toolName, ext.path);
+      }
+      for (let flagName of ext.flags.keys()) {
+        let existingOwner = flagOwners.get(flagName);
+        existingOwner && existingOwner !== ext.path ? conflicts.push({
+          path: ext.path,
+          message: `Flag "--${flagName}" conflicts with ${existingOwner}`
+        }) : flagOwners.set(flagName, ext.path);
+      }
+    }
+    return conflicts;
+  }
+};
+
+export {
+  createEventBus,
+  createSyntheticSourceInfo,
+  createExtensionRuntime,
+  discoverAndLoadExtensions,
+  expandPromptTemplate,
+  loadSkillsFromDir,
+  formatSkillsForPrompt,
+  loadSkills,
+  loadProjectContextFiles,
+  DefaultResourceLoader
+};