@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/package-manager-cli-C4EJOO5Q.js

@@ -0,0 +1,751 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  createProjectTrustContext,
+  resolveProjectTrusted
+} from "./chunk-ISQDQIZN.js";
+import {
+  ProjectTrustStore,
+  hasTrustRequiringProjectResources
+} from "./chunk-LTXUQJI4.js";
+import {
+  DefaultPackageManager,
+  DefaultResourceLoader
+} from "./chunk-T5GM5BFH.js";
+import "./chunk-OBMWP3I5.js";
+import "./chunk-DVGWF6A2.js";
+import "./chunk-QFWG2RVL.js";
+import "./chunk-CGBXPL3E.js";
+import "./chunk-M3LZLQW2.js";
+import {
+  SettingsManager
+} from "./chunk-5NWQCSKR.js";
+import "./chunk-URD2SLIT.js";
+import "./chunk-5OLJGVCB.js";
+import "./chunk-AY6CAJSL.js";
+import "./chunk-PVCDKGR6.js";
+import "./chunk-MJQDX3BA.js";
+import "./chunk-MGWCVY6Y.js";
+import "./chunk-I6R76AG7.js";
+import "./chunk-CH6OL6P2.js";
+import {
+  DynamicBorder
+} from "./chunk-3GHXVUAK.js";
+import {
+  keyHint,
+  rawKeyHint
+} from "./chunk-C4O2RSQQ.js";
+import {
+  initTheme,
+  stopThemeWatcher,
+  theme
+} from "./chunk-MX3GJNXJ.js";
+import {
+  APP_NAME,
+  CONFIG_DIR_NAME,
+  canonicalizePath,
+  getAgentDir,
+  isLocalPath,
+  resolvePath
+} from "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/package-manager-cli.js
+import chalk from "chalk";
+
+// packages/coding-agent/dist/cli/config-selector.js
+import { ProcessTerminal, TUI } from "@ashx-j/lunr-tui";
+
+// packages/coding-agent/dist/modes/interactive/components/config-selector.js
+import { homedir } from "node:os";
+import { basename, dirname, join, relative } from "node:path";
+import { Container, getKeybindings, Input, matchesKey, Spacer, truncateToWidth, visibleWidth } from "@ashx-j/lunr-tui";
+var RESOURCE_TYPES = ["extensions", "skills", "prompts", "themes"], RESOURCE_TYPE_LABELS = {
+  extensions: "Extensions",
+  skills: "Skills",
+  prompts: "Prompts",
+  themes: "Themes"
+};
+function formatBaseDir(baseDir) {
+  let homeDir = homedir(), displayPath;
+  return baseDir === homeDir ? displayPath = "~" : baseDir.startsWith(homeDir) ? displayPath = `~${baseDir.slice(homeDir.length).replace(/\\/g, "/")}` : displayPath = baseDir.replace(/\\/g, "/"), displayPath.endsWith("/") ? displayPath : `${displayPath}/`;
+}
+function getGroupLabel(metadata, agentDir) {
+  return metadata.origin === "package" ? `${metadata.source} (${metadata.scope})` : metadata.source === "auto" ? metadata.baseDir ? metadata.scope === "user" ? `User (${formatBaseDir(metadata.baseDir)})` : `Project (${formatBaseDir(metadata.baseDir)})` : metadata.scope === "user" ? `User (${formatBaseDir(agentDir)})` : `Project (${CONFIG_DIR_NAME}/)` : metadata.scope === "user" ? "User settings" : "Project settings";
+}
+function buildGroups(resolved, agentDir) {
+  let groupMap = /* @__PURE__ */ new Map(), addToGroup = (resources, resourceType) => {
+    for (let res of resources) {
+      let { path, enabled, metadata } = res, groupKey = `${metadata.origin}:${metadata.scope}:${metadata.source}:${metadata.baseDir ?? ""}`;
+      groupMap.has(groupKey) || groupMap.set(groupKey, {
+        key: groupKey,
+        label: getGroupLabel(metadata, agentDir),
+        scope: metadata.scope,
+        origin: metadata.origin,
+        source: metadata.source,
+        subgroups: []
+      });
+      let group = groupMap.get(groupKey), subgroupKey = `${groupKey}:${resourceType}`, subgroup = group.subgroups.find((sg) => sg.type === resourceType);
+      subgroup || (subgroup = {
+        type: resourceType,
+        label: RESOURCE_TYPE_LABELS[resourceType],
+        items: []
+      }, group.subgroups.push(subgroup));
+      let fileName = basename(path), parentFolder = basename(dirname(path)), displayName;
+      resourceType === "extensions" && parentFolder !== "extensions" ? displayName = `${parentFolder}/${fileName}` : resourceType === "skills" && fileName === "SKILL.md" ? displayName = parentFolder : displayName = fileName, subgroup.items.push({
+        path,
+        enabled,
+        metadata,
+        resourceType,
+        displayName,
+        groupKey,
+        subgroupKey
+      });
+    }
+  };
+  addToGroup(resolved.extensions, "extensions"), addToGroup(resolved.skills, "skills"), addToGroup(resolved.prompts, "prompts"), addToGroup(resolved.themes, "themes");
+  let groups = Array.from(groupMap.values());
+  groups.sort((a, b) => a.origin !== b.origin ? a.origin === "package" ? -1 : 1 : a.scope !== b.scope ? a.scope === "user" ? -1 : 1 : a.source.localeCompare(b.source));
+  let typeOrder = { extensions: 0, skills: 1, prompts: 2, themes: 3 };
+  for (let group of groups) {
+    group.subgroups.sort((a, b) => typeOrder[a.type] - typeOrder[b.type]);
+    for (let subgroup of group.subgroups)
+      subgroup.items.sort((a, b) => a.displayName.localeCompare(b.displayName));
+  }
+  return groups;
+}
+var ConfigSelectorHeader = class {
+  writeScope;
+  projectModeAvailable;
+  constructor(writeScope, projectModeAvailable) {
+    this.writeScope = writeScope, this.projectModeAvailable = projectModeAvailable;
+  }
+  setWriteScope(writeScope) {
+    this.writeScope = writeScope;
+  }
+  invalidate() {
+  }
+  render(width) {
+    let title = theme.bold(this.writeScope === "project" ? "Project Local Resources" : "Global Resources"), sep = theme.fg("muted", " \xB7 "), switchHint = this.projectModeAvailable ? keyHint("tui.input.tab", "switch mode") + sep : "", actionHint = this.writeScope === "project" ? rawKeyHint("space", "cycle inherit/+/-") : rawKeyHint("space", "toggle"), hint = switchHint + actionHint + sep + rawKeyHint("esc", "close"), spacing = Math.max(1, width - visibleWidth(title) - visibleWidth(hint)), scopeHint = this.writeScope === "project" ? theme.fg("muted", `${CONFIG_DIR_NAME}/settings.json \xB7 inherited global resources are dimmed`) : theme.fg("muted", `~/${CONFIG_DIR_NAME}/agent/settings.json`);
+    return [
+      truncateToWidth(`${title}${" ".repeat(spacing)}${hint}`, width, ""),
+      truncateToWidth(scopeHint, width, "")
+    ];
+  }
+}, ResourceList = class {
+  groupsByScope;
+  flatItems = [];
+  filteredItems = [];
+  selectedIndex = 0;
+  searchInput;
+  maxVisible;
+  settingsManager;
+  cwd;
+  agentDir;
+  writeScope;
+  inheritedEnabledByKey;
+  onCancel;
+  onExit;
+  onToggle;
+  onSwitchMode;
+  _focused = !1;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value, this.searchInput.focused = value;
+  }
+  constructor(groupsByScope, settingsManager, cwd, agentDir, terminalHeight, writeScope = "global") {
+    this.groupsByScope = groupsByScope, this.settingsManager = settingsManager, this.cwd = cwd, this.agentDir = agentDir, this.writeScope = writeScope, this.inheritedEnabledByKey = this.buildInheritedEnabledMap(groupsByScope.global), this.searchInput = new Input();
+    let chrome = 8;
+    this.maxVisible = Math.max(5, (terminalHeight ?? 24) - chrome), this.buildFlatList(), this.filteredItems = [...this.flatItems];
+  }
+  setWriteScope(writeScope) {
+    this.writeScope = writeScope, this.buildFlatList(), this.filterItems(this.searchInput.getValue());
+  }
+  get groups() {
+    return this.groupsByScope[this.writeScope];
+  }
+  buildInheritedEnabledMap(groups) {
+    let result = /* @__PURE__ */ new Map();
+    for (let group of groups)
+      for (let subgroup of group.subgroups)
+        for (let item of subgroup.items)
+          result.set(this.getResourceItemKey(item), item.enabled);
+    return result;
+  }
+  buildFlatList() {
+    this.flatItems = [];
+    for (let group of this.groups) {
+      this.flatItems.push({ type: "group", group });
+      for (let subgroup of group.subgroups) {
+        this.flatItems.push({ type: "subgroup", subgroup, group });
+        for (let item of subgroup.items)
+          this.flatItems.push({ type: "item", item });
+      }
+    }
+    this.selectedIndex = this.flatItems.findIndex((e) => e.type === "item"), this.selectedIndex < 0 && (this.selectedIndex = 0);
+  }
+  findNextItem(fromIndex, direction) {
+    let idx = fromIndex + direction;
+    for (; idx >= 0 && idx < this.filteredItems.length; ) {
+      if (this.filteredItems[idx].type === "item")
+        return idx;
+      idx += direction;
+    }
+    return fromIndex;
+  }
+  filterItems(query) {
+    if (!query.trim()) {
+      this.filteredItems = [...this.flatItems], this.selectFirstItem();
+      return;
+    }
+    let lowerQuery = query.toLowerCase(), matchingItems = /* @__PURE__ */ new Set(), matchingSubgroups = /* @__PURE__ */ new Set(), matchingGroups = /* @__PURE__ */ new Set();
+    for (let entry of this.flatItems)
+      if (entry.type === "item") {
+        let item = entry.item;
+        (item.displayName.toLowerCase().includes(lowerQuery) || item.resourceType.toLowerCase().includes(lowerQuery) || item.path.toLowerCase().includes(lowerQuery)) && matchingItems.add(item);
+      }
+    for (let group of this.groups)
+      for (let subgroup of group.subgroups)
+        for (let item of subgroup.items)
+          matchingItems.has(item) && (matchingSubgroups.add(subgroup), matchingGroups.add(group));
+    this.filteredItems = [];
+    for (let entry of this.flatItems)
+      entry.type === "group" && matchingGroups.has(entry.group) ? this.filteredItems.push(entry) : entry.type === "subgroup" && matchingSubgroups.has(entry.subgroup) ? this.filteredItems.push(entry) : entry.type === "item" && matchingItems.has(entry.item) && this.filteredItems.push(entry);
+    this.selectFirstItem();
+  }
+  selectFirstItem() {
+    let firstItemIndex = this.filteredItems.findIndex((e) => e.type === "item");
+    this.selectedIndex = firstItemIndex >= 0 ? firstItemIndex : 0;
+  }
+  updateItem(item, enabled) {
+    item.enabled = enabled;
+    for (let group of this.groups)
+      for (let subgroup of group.subgroups) {
+        let found = subgroup.items.find((i) => i.path === item.path && i.resourceType === item.resourceType);
+        if (found) {
+          found.enabled = enabled;
+          return;
+        }
+      }
+  }
+  invalidate() {
+  }
+  render(width) {
+    let lines = [];
+    if (lines.push(...this.searchInput.render(width)), lines.push(""), this.filteredItems.length === 0)
+      return lines.push(theme.fg("muted", "  No resources found")), lines;
+    let startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.filteredItems.length - this.maxVisible)), endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+    for (let i = startIndex; i < endIndex; i++) {
+      let entry = this.filteredItems[i], isSelected = i === this.selectedIndex;
+      if (entry.type === "group") {
+        let inherited = this.writeScope === "project" && entry.group.scope === "user", label = theme.bold(`${entry.group.label}${inherited ? " \xB7 inherited global" : ""}`), groupLine = theme.fg(inherited ? "dim" : "accent", label);
+        lines.push(truncateToWidth(`  ${groupLine}`, width, ""));
+      } else if (entry.type === "subgroup") {
+        let color = this.writeScope === "project" && entry.group.scope === "user" ? "dim" : "muted", subgroupLine = theme.fg(color, entry.subgroup.label);
+        lines.push(truncateToWidth(`    ${subgroupLine}`, width, ""));
+      } else {
+        let item = entry.item, cursor = isSelected ? "> " : "  ", dimmed = this.isDimmedItem(item), nameText = isSelected && !dimmed ? theme.bold(item.displayName) : item.displayName, name = dimmed ? theme.fg("dim", nameText) : nameText;
+        lines.push(truncateToWidth(`${cursor}    ${this.renderCheckbox(item)} ${name}${this.getItemSuffix(item)}`, width, "..."));
+      }
+    }
+    if (startIndex > 0 || endIndex < this.filteredItems.length) {
+      let itemCount = this.filteredItems.filter((e) => e.type === "item").length, currentItemIndex = this.filteredItems.slice(0, this.selectedIndex).filter((e) => e.type === "item").length + 1;
+      lines.push(theme.fg("dim", `  (${currentItemIndex}/${itemCount})`));
+    }
+    return lines;
+  }
+  handleInput(data) {
+    let kb = getKeybindings();
+    if (kb.matches(data, "tui.select.up")) {
+      this.selectedIndex = this.findNextItem(this.selectedIndex, -1);
+      return;
+    }
+    if (kb.matches(data, "tui.select.down")) {
+      this.selectedIndex = this.findNextItem(this.selectedIndex, 1);
+      return;
+    }
+    if (kb.matches(data, "tui.select.pageUp")) {
+      let target = Math.max(0, this.selectedIndex - this.maxVisible);
+      for (; target < this.filteredItems.length && this.filteredItems[target].type !== "item"; )
+        target++;
+      target < this.filteredItems.length && (this.selectedIndex = target);
+      return;
+    }
+    if (kb.matches(data, "tui.select.pageDown")) {
+      let target = Math.min(this.filteredItems.length - 1, this.selectedIndex + this.maxVisible);
+      for (; target >= 0 && this.filteredItems[target].type !== "item"; )
+        target--;
+      target >= 0 && (this.selectedIndex = target);
+      return;
+    }
+    if (kb.matches(data, "tui.select.cancel")) {
+      this.onCancel?.();
+      return;
+    }
+    if (matchesKey(data, "ctrl+c")) {
+      this.onExit?.();
+      return;
+    }
+    if (kb.matches(data, "tui.input.tab")) {
+      this.onSwitchMode?.();
+      return;
+    }
+    if (data === " " || kb.matches(data, "tui.select.confirm")) {
+      let entry = this.filteredItems[this.selectedIndex];
+      if (entry?.type === "item" && (this.writeScope === "project" || this.getItemScope(entry.item) === "user")) {
+        let newEnabled = this.toggleResource(entry.item);
+        newEnabled !== void 0 && (this.updateItem(entry.item, newEnabled), this.onToggle?.(entry.item, newEnabled));
+      }
+      return;
+    }
+    this.searchInput.handleInput(data), this.filterItems(this.searchInput.getValue());
+  }
+  toggleResource(item) {
+    if (this.writeScope === "project") {
+      let state = this.getNextOverrideState(item);
+      return this.setProjectResourceOverride(item, state) ? state === "inherit" ? this.getInheritedEnabled(item) : state === "load" : void 0;
+    }
+    let enabled = !item.enabled;
+    return item.metadata.origin === "top-level" ? this.toggleTopLevelResource(item, enabled) : this.togglePackageResource(item, enabled), enabled;
+  }
+  toggleTopLevelResource(item, enabled) {
+    let scope = item.metadata.scope, settings = scope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings(), arrayKey = item.resourceType, current = settings[arrayKey] ?? [], pattern = this.getResourcePattern(item), disablePattern = `-${pattern}`, enablePattern = `+${pattern}`, updated = current.filter((p) => (p.startsWith("!") || p.startsWith("+") || p.startsWith("-") ? p.slice(1) : p) !== pattern);
+    enabled ? updated.push(enablePattern) : updated.push(disablePattern), scope === "project" ? arrayKey === "extensions" ? this.settingsManager.setProjectExtensionPaths(updated) : arrayKey === "skills" ? this.settingsManager.setProjectSkillPaths(updated) : arrayKey === "prompts" ? this.settingsManager.setProjectPromptTemplatePaths(updated) : arrayKey === "themes" && this.settingsManager.setProjectThemePaths(updated) : arrayKey === "extensions" ? this.settingsManager.setExtensionPaths(updated) : arrayKey === "skills" ? this.settingsManager.setSkillPaths(updated) : arrayKey === "prompts" ? this.settingsManager.setPromptTemplatePaths(updated) : arrayKey === "themes" && this.settingsManager.setThemePaths(updated);
+  }
+  togglePackageResource(item, enabled) {
+    let scope = item.metadata.scope, packages = [...(scope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings()).packages ?? []], pkgIndex = packages.findIndex((pkg2) => (typeof pkg2 == "string" ? pkg2 : pkg2.source) === item.metadata.source);
+    if (pkgIndex === -1)
+      return;
+    let pkg = packages[pkgIndex];
+    typeof pkg == "string" && (pkg = { source: pkg }, packages[pkgIndex] = pkg);
+    let arrayKey = item.resourceType, current = pkg[arrayKey] ?? [], pattern = this.getPackageResourcePattern(item), disablePattern = `-${pattern}`, enablePattern = `+${pattern}`, updated = current.filter((p) => (p.startsWith("!") || p.startsWith("+") || p.startsWith("-") ? p.slice(1) : p) !== pattern);
+    enabled ? updated.push(enablePattern) : updated.push(disablePattern), pkg[arrayKey] = updated.length > 0 ? updated : void 0, ["extensions", "skills", "prompts", "themes"].some((k) => pkg[k] !== void 0) || (packages[pkgIndex] = pkg.source), scope === "project" ? this.settingsManager.setProjectPackages(packages) : this.settingsManager.setPackages(packages);
+  }
+  renderCheckbox(item) {
+    if (this.writeScope === "project") {
+      let state = this.getProjectOverrideState(item);
+      return state === "load" ? theme.fg("success", "[+]") : state === "unload" ? theme.fg("warning", "[-]") : theme.fg("dim", item.enabled ? "[x]" : "[ ]");
+    }
+    return item.enabled ? theme.fg("success", "[x]") : theme.fg("dim", "[ ]");
+  }
+  getItemSuffix(item) {
+    if (this.writeScope !== "project")
+      return "";
+    let state = this.getProjectOverrideState(item);
+    return state === "load" ? theme.fg("muted", "  project load") : state === "unload" ? theme.fg("muted", "  project unload") : this.isInheritedGlobalItem(item) ? theme.fg("dim", "  inherited global") : "";
+  }
+  isDimmedItem(item) {
+    return this.writeScope === "project" && this.isInheritedGlobalItem(item) && this.getProjectOverrideState(item) === "inherit";
+  }
+  setProjectResourceOverride(item, state) {
+    return item.metadata.origin === "top-level" ? this.setProjectTopLevelOverride(item, state) : this.setProjectPackageOverride(item, state);
+  }
+  setProjectTopLevelOverride(item, state) {
+    let current = this.settingsManager.getProjectSettings()[item.resourceType] ?? [], pattern = this.isInheritedGlobalItem(item) ? item.path : this.getResourcePatternForScope(item, "project"), patterns = this.getTopLevelOverridePatterns(item, "project"), updated = current.filter((entry) => {
+      let target = this.getPatternEntryTarget(entry);
+      return (entry.startsWith("!") || entry.startsWith("+") || entry.startsWith("-")) && patterns.has(target) ? !1 : !(state === "inherit" && this.isInheritedGlobalItem(item) && target === pattern);
+    });
+    return state !== "inherit" && (this.isInheritedGlobalItem(item) && !updated.includes(pattern) && updated.push(pattern), updated.push(`${state === "load" ? "+" : "-"}${pattern}`)), this.setProjectTopLevelPaths(item.resourceType, updated), !0;
+  }
+  setProjectTopLevelPaths(key, paths) {
+    key === "extensions" ? this.settingsManager.setProjectExtensionPaths(paths) : key === "skills" ? this.settingsManager.setProjectSkillPaths(paths) : key === "prompts" ? this.settingsManager.setProjectPromptTemplatePaths(paths) : this.settingsManager.setProjectThemePaths(paths);
+  }
+  setProjectPackageOverride(item, state) {
+    let packages = [...this.settingsManager.getProjectSettings().packages ?? []], pkgIndex = packages.findIndex((pkg2) => this.packageSourceStringMatches(item.metadata.source, this.getItemScope(item), typeof pkg2 == "string" ? pkg2 : pkg2.source, "project"));
+    if (pkgIndex === -1) {
+      if (state === "inherit")
+        return !1;
+      packages.push(this.createPackageOverrideSource(item)), pkgIndex = packages.length - 1;
+    }
+    let pkg = packages[pkgIndex];
+    if (pkg === void 0)
+      return !1;
+    typeof pkg == "string" && (pkg = { source: pkg }, packages[pkgIndex] = pkg);
+    let pattern = this.getPackageResourcePattern(item), updated = (pkg[item.resourceType] ?? []).filter((entry) => this.getPatternEntryTarget(entry) !== pattern);
+    return state !== "inherit" && updated.push(`${state === "load" ? "+" : "-"}${pattern}`), pkg[item.resourceType] = updated.length > 0 ? updated : void 0, RESOURCE_TYPES.some((key) => pkg[key] !== void 0) || (pkg.autoload === !1 ? packages.splice(pkgIndex, 1) : packages[pkgIndex] = pkg.source), this.settingsManager.setProjectPackages(packages), !0;
+  }
+  getNextOverrideState(item) {
+    let state = this.getProjectOverrideState(item), inheritedEnabled = this.getInheritedEnabled(item);
+    return state === "inherit" ? inheritedEnabled ? "unload" : "load" : state === "unload" ? inheritedEnabled ? "load" : "inherit" : inheritedEnabled ? "inherit" : "unload";
+  }
+  getProjectOverrideState(item) {
+    if (this.writeScope !== "project")
+      return "inherit";
+    if (item.metadata.origin === "top-level")
+      return this.getOverrideStateFromEntries(this.settingsManager.getProjectSettings()[item.resourceType] ?? [], this.getTopLevelOverridePatterns(item, "project"), !1);
+    let pkg = this.findMatchingPackageSource(item, "project");
+    if (typeof pkg != "object")
+      return "inherit";
+    let entries = pkg[item.resourceType];
+    return entries === void 0 ? "inherit" : this.getOverrideStateFromEntries(entries, /* @__PURE__ */ new Set([this.getPackageResourcePattern(item)]), pkg.autoload !== !1);
+  }
+  getOverrideStateFromEntries(entries, patterns, emptyArrayIsUnload) {
+    if (entries.length === 0 && emptyArrayIsUnload)
+      return "unload";
+    let state = "inherit";
+    for (let entry of entries)
+      patterns.has(this.getPatternEntryTarget(entry)) && (entry.startsWith("!") || entry.startsWith("-") ? state = "unload" : state = "load");
+    return state;
+  }
+  getInheritedEnabled(item) {
+    return this.inheritedEnabledByKey.get(this.getResourceItemKey(item)) ?? (this.getItemScope(item) === "user" ? item.enabled : !0);
+  }
+  isInheritedGlobalItem(item) {
+    return this.getItemScope(item) === "user" || this.inheritedEnabledByKey.has(this.getResourceItemKey(item));
+  }
+  getTopLevelOverridePatterns(item, scope) {
+    let baseDir = this.getTopLevelBaseDir(scope), patterns = /* @__PURE__ */ new Set([
+      this.getResourcePatternForScope(item, scope),
+      item.path,
+      relative(baseDir, item.path)
+    ]);
+    return item.metadata.baseDir && patterns.add(relative(item.metadata.baseDir, item.path)), patterns;
+  }
+  getResourcePatternForScope(item, scope) {
+    let sourceScope = this.getItemScope(item);
+    if (scope !== sourceScope)
+      return item.path;
+    let baseDir = item.metadata.baseDir ?? this.getTopLevelBaseDir(sourceScope);
+    return relative(baseDir, item.path);
+  }
+  createPackageOverrideSource(item) {
+    let source = item.metadata.source;
+    if (!isLocalPath(source))
+      return { source, autoload: !1 };
+    let sourcePath = resolvePath(source, this.getTopLevelBaseDir(this.getItemScope(item)), { trim: !0 });
+    return { source: relative(this.getTopLevelBaseDir("project"), sourcePath) || ".", autoload: !1 };
+  }
+  packageSourceStringMatches(leftSource, leftScope, rightSource, rightScope) {
+    if (leftSource === rightSource)
+      return !0;
+    if (!isLocalPath(leftSource) || !isLocalPath(rightSource))
+      return !1;
+    let left = resolvePath(leftSource, this.getTopLevelBaseDir(leftScope), { trim: !0 }), right = resolvePath(rightSource, this.getTopLevelBaseDir(rightScope), { trim: !0 });
+    return left === right;
+  }
+  findMatchingPackageSource(item, targetScope) {
+    return ((targetScope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings()).packages ?? []).find((pkg) => this.packageSourceStringMatches(item.metadata.source, this.getItemScope(item), typeof pkg == "string" ? pkg : pkg.source, targetScope));
+  }
+  getPatternEntryTarget(entry) {
+    return entry.startsWith("!") || entry.startsWith("+") || entry.startsWith("-") ? entry.slice(1) : entry;
+  }
+  getResourceItemKey(item) {
+    return `${item.resourceType}:${canonicalizePath(item.path)}`;
+  }
+  getItemScope(item) {
+    return item.metadata.scope === "project" ? "project" : "user";
+  }
+  getTopLevelBaseDir(scope) {
+    return scope === "project" ? join(this.cwd, CONFIG_DIR_NAME) : this.agentDir;
+  }
+  getResourcePattern(item) {
+    let scope = item.metadata.scope, baseDir = item.metadata.baseDir ?? this.getTopLevelBaseDir(scope);
+    return relative(baseDir, item.path);
+  }
+  getPackageResourcePattern(item) {
+    let baseDir = item.metadata.baseDir ?? dirname(item.path);
+    return relative(baseDir, item.path);
+  }
+}, ConfigSelectorComponent = class extends Container {
+  header;
+  resourceList;
+  writeScope;
+  _focused = !1;
+  get focused() {
+    return this._focused;
+  }
+  set focused(value) {
+    this._focused = value, this.resourceList.focused = value;
+  }
+  constructor(resolvedPaths, settingsManager, cwd, agentDir, onClose, onExit, requestRender, terminalHeight, writeScope = "global", projectModeAvailable = !0) {
+    super(), this.writeScope = writeScope;
+    let groupsByScope = {
+      global: buildGroups(resolvedPaths.global, agentDir),
+      project: buildGroups(resolvedPaths.project, agentDir)
+    };
+    this.addChild(new Spacer(1)), this.addChild(new DynamicBorder()), this.addChild(new Spacer(1)), this.header = new ConfigSelectorHeader(this.writeScope, projectModeAvailable), this.addChild(this.header), this.addChild(new Spacer(1)), this.resourceList = new ResourceList(groupsByScope, settingsManager, cwd, agentDir, terminalHeight, this.writeScope), this.resourceList.onCancel = onClose, this.resourceList.onExit = onExit, this.resourceList.onToggle = () => requestRender(), projectModeAvailable && (this.resourceList.onSwitchMode = () => {
+      this.switchWriteScope(), requestRender();
+    }), this.addChild(this.resourceList), this.addChild(new Spacer(1)), this.addChild(new DynamicBorder());
+  }
+  switchWriteScope() {
+    this.writeScope = this.writeScope === "global" ? "project" : "global", this.header.setWriteScope(this.writeScope), this.resourceList.setWriteScope(this.writeScope);
+  }
+  getResourceList() {
+    return this.resourceList;
+  }
+};
+
+// packages/coding-agent/dist/cli/config-selector.js
+async function selectConfig(options) {
+  return initTheme(options.settingsManager.getTheme(), !0), new Promise((resolve) => {
+    let ui = new TUI(new ProcessTerminal()), resolved = !1, selector = new ConfigSelectorComponent(options.resolvedPaths, options.settingsManager, options.cwd, options.agentDir, () => {
+      resolved || (resolved = !0, ui.stop(), stopThemeWatcher(), resolve());
+    }, () => {
+      ui.stop(), stopThemeWatcher(), process.exit(0);
+    }, () => ui.requestRender(), ui.terminal.rows, options.writeScope, options.projectModeAvailable);
+    ui.addChild(selector), ui.setFocus(selector.getResourceList()), ui.start();
+  });
+}
+
+// packages/coding-agent/dist/package-manager-cli.js
+function reportSettingsErrors(settingsManager, context) {
+  let errors = settingsManager.drainErrors();
+  for (let { scope, error } of errors)
+    console.error(chalk.yellow(`Warning (${context}, ${scope} settings): ${error.message}`)), error.stack && console.error(chalk.dim(error.stack));
+}
+function getPackageCommandUsage(command) {
+  switch (command) {
+    case "install":
+      return `${APP_NAME} install <source> [-l] [--approve|--no-approve]`;
+    case "remove":
+      return `${APP_NAME} remove <source> [-l] [--approve|--no-approve]`;
+    case "list":
+      return `${APP_NAME} list [--approve|--no-approve]`;
+  }
+}
+var CONFIG_COMMAND_USAGE = `${APP_NAME} config [-l] [--approve|--no-approve]`;
+function printConfigCommandHelp() {
+  console.log(`${chalk.bold("Usage:")}
+  ${CONFIG_COMMAND_USAGE}
+
+Open the resource configuration TUI to enable or disable package resources.
+Without -l, starts in global settings (~/${CONFIG_DIR_NAME}/agent/settings.json).
+Press Tab in the TUI to switch between global and project-local modes.
+
+Options:
+  -l, --local       Edit project overrides (${CONFIG_DIR_NAME}/settings.json)
+  -a, --approve     Trust project-local files for this command with -l
+  -na, --no-approve Ignore project-local files for this command with -l
+`);
+}
+function printPackageCommandHelp(command) {
+  switch (command) {
+    case "install":
+      console.log(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage("install")}
+
+Install a package and add it to settings.
+
+Options:
+  -l, --local       Install project-locally (${CONFIG_DIR_NAME}/settings.json)
+  -a, --approve     Trust project-local files for this command
+  -na, --no-approve Ignore project-local files for this command
+
+Examples:
+  ${APP_NAME} install npm:@foo/bar
+  ${APP_NAME} install git:github.com/user/repo
+  ${APP_NAME} install git:git@github.com:user/repo
+  ${APP_NAME} install https://github.com/user/repo
+  ${APP_NAME} install ssh://git@github.com/user/repo
+  ${APP_NAME} install ./local/path
+`);
+      return;
+    case "remove":
+      console.log(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage("remove")}
+
+Remove a package and its source from settings.
+Alias: ${APP_NAME} uninstall <source> [-l]
+
+Options:
+  -l, --local       Remove from project settings (${CONFIG_DIR_NAME}/settings.json)
+  -a, --approve     Trust project-local files for this command
+  -na, --no-approve Ignore project-local files for this command
+
+Examples:
+  ${APP_NAME} remove npm:@foo/bar
+  ${APP_NAME} uninstall npm:@foo/bar
+`);
+      return;
+    case "list":
+      console.log(`${chalk.bold("Usage:")}
+  ${getPackageCommandUsage("list")}
+
+List installed packages from user and project settings.
+
+Options:
+  -a, --approve      Trust project-local files for this command
+  -na, --no-approve  Ignore project-local files for this command
+`);
+      return;
+  }
+}
+function parsePackageCommand(args) {
+  let [rawCommand, ...rest] = args, command;
+  if (rawCommand === "uninstall" ? command = "remove" : (rawCommand === "install" || rawCommand === "remove" || rawCommand === "list") && (command = rawCommand), !command)
+    return;
+  let local = !1, projectTrustOverride, help = !1, invalidOption, invalidArgument, source;
+  for (let index = 0; index < rest.length; index++) {
+    let arg = rest[index];
+    if (arg === "-h" || arg === "--help") {
+      help = !0;
+      continue;
+    }
+    if (arg === "-l" || arg === "--local") {
+      command === "install" || command === "remove" ? local = !0 : invalidOption = invalidOption ?? arg;
+      continue;
+    }
+    if (arg === "--approve" || arg === "-a") {
+      projectTrustOverride = !0;
+      continue;
+    }
+    if (arg === "--no-approve" || arg === "-na") {
+      projectTrustOverride = !1;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      invalidOption = invalidOption ?? arg;
+      continue;
+    }
+    source ? invalidArgument = invalidArgument ?? arg : source = arg;
+  }
+  return {
+    command,
+    source,
+    local,
+    projectTrustOverride,
+    help,
+    invalidOption,
+    invalidArgument
+  };
+}
+function getCommandAppMode() {
+  return process.stdin.isTTY && process.stdout.isTTY ? "interactive" : "print";
+}
+function reportProjectTrustWarnings(warnings) {
+  for (let warning of warnings)
+    console.error(chalk.yellow(`Warning: ${warning}`));
+}
+async function createCommandSettingsManager(options) {
+  let settingsManager = SettingsManager.create(options.cwd, options.agentDir, { projectTrusted: !1 }), projectTrustWarnings = [], trustStore = new ProjectTrustStore(options.agentDir);
+  if (options.useSavedProjectTrustOnly) {
+    let savedProjectTrusted = trustStore.get(options.cwd) === !0;
+    return settingsManager.setProjectTrusted(options.projectTrustOverride ?? savedProjectTrusted), { settingsManager, projectTrustWarnings };
+  }
+  let appMode = getCommandAppMode(), extensionsResult = options.projectTrustOverride === void 0 && hasTrustRequiringProjectResources(options.cwd) ? await new DefaultResourceLoader({
+    cwd: options.cwd,
+    agentDir: options.agentDir,
+    settingsManager,
+    extensionFactories: options.extensionFactories
+  }).loadProjectTrustExtensions() : void 0;
+  for (let error of extensionsResult?.errors ?? [])
+    projectTrustWarnings.push(`Failed to load extension "${error.path}": ${error.error}`);
+  let projectTrusted = await resolveProjectTrusted({
+    cwd: options.cwd,
+    trustStore,
+    trustOverride: options.projectTrustOverride,
+    defaultProjectTrust: settingsManager.getDefaultProjectTrust(),
+    extensionsResult,
+    projectTrustContext: createProjectTrustContext({
+      cwd: options.cwd,
+      mode: appMode,
+      settingsManager,
+      hasUI: appMode === "interactive"
+    }),
+    onExtensionError: (message) => projectTrustWarnings.push(message)
+  });
+  return settingsManager.setProjectTrusted(projectTrusted), { settingsManager, projectTrustWarnings };
+}
+async function handleConfigCommand(args, runtimeOptions = {}) {
+  let [command, ...rest] = args;
+  if (command !== "config")
+    return !1;
+  if (rest.includes("-h") || rest.includes("--help"))
+    return printConfigCommandHelp(), !0;
+  let local = !1, projectTrustOverride;
+  for (let arg of rest)
+    if (arg === "-l" || arg === "--local")
+      local = !0;
+    else if (arg === "-a" || arg === "--approve")
+      projectTrustOverride = !0;
+    else if (arg === "-na" || arg === "--no-approve")
+      projectTrustOverride = !1;
+    else return arg.startsWith("-") ? (console.error(chalk.red(`Unknown option ${arg} for "config".`)), console.error(chalk.dim(`Use "${APP_NAME} --help" or "${CONFIG_COMMAND_USAGE}".`)), process.exitCode = 1, !0) : (console.error(chalk.red(`Unexpected argument ${arg}.`)), console.error(chalk.dim(`Usage: ${CONFIG_COMMAND_USAGE}`)), process.exitCode = 1, !0);
+  let cwd = process.cwd(), agentDir = getAgentDir(), { settingsManager, projectTrustWarnings } = await createCommandSettingsManager({
+    cwd,
+    agentDir,
+    projectTrustOverride,
+    extensionFactories: runtimeOptions.extensionFactories
+  });
+  if (reportProjectTrustWarnings(projectTrustWarnings), local && !settingsManager.isProjectTrusted())
+    return console.error(chalk.red("Project is not trusted. Use --approve to modify local resource config.")), process.exitCode = 1, !0;
+  reportSettingsErrors(settingsManager, "config command");
+  let globalSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: !1 }), globalResolvedPaths = await new DefaultPackageManager({
+    cwd,
+    agentDir,
+    settingsManager: globalSettingsManager
+  }).resolve(), projectResolvedPaths = settingsManager.isProjectTrusted() ? await new DefaultPackageManager({ cwd, agentDir, settingsManager }).resolve() : globalResolvedPaths;
+  await selectConfig({
+    resolvedPaths: { global: globalResolvedPaths, project: projectResolvedPaths },
+    settingsManager,
+    cwd,
+    agentDir,
+    writeScope: local ? "project" : "global",
+    projectModeAvailable: settingsManager.isProjectTrusted()
+  }), process.exit(0);
+}
+async function handlePackageCommand(args, runtimeOptions = {}) {
+  let options = parsePackageCommand(args);
+  if (!options)
+    return !1;
+  if (options.help)
+    return printPackageCommandHelp(options.command), !0;
+  if (options.invalidOption)
+    return console.error(chalk.red(`Unknown option ${options.invalidOption} for "${options.command}".`)), console.error(chalk.dim(`Use "${APP_NAME} --help" or "${getPackageCommandUsage(options.command)}".`)), process.exitCode = 1, !0;
+  if (options.invalidArgument)
+    return console.error(chalk.red(`Unexpected argument ${options.invalidArgument}.`)), console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`)), process.exitCode = 1, !0;
+  let source = options.source;
+  if ((options.command === "install" || options.command === "remove") && !source)
+    return console.error(chalk.red(`Missing ${options.command} source.`)), console.error(chalk.dim(`Usage: ${getPackageCommandUsage(options.command)}`)), process.exitCode = 1, !0;
+  let cwd = process.cwd(), agentDir = getAgentDir(), writesProjectPackageConfig = (options.command === "install" || options.command === "remove") && options.local, { settingsManager, projectTrustWarnings } = await createCommandSettingsManager({
+    cwd,
+    agentDir,
+    projectTrustOverride: options.projectTrustOverride,
+    extensionFactories: runtimeOptions.extensionFactories
+  });
+  if (reportProjectTrustWarnings(projectTrustWarnings), !settingsManager.isProjectTrusted() && writesProjectPackageConfig)
+    return console.error(chalk.red("Project is not trusted. Use --approve to modify local package config.")), process.exitCode = 1, !0;
+  reportSettingsErrors(settingsManager, "package command");
+  let packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+  packageManager.setProgressCallback((event) => {
+    event.type === "start" && process.stdout.write(chalk.dim(`${event.message}
+`));
+  });
+  try {
+    switch (options.command) {
+      case "install":
+        return await packageManager.installAndPersist(source, { local: options.local }), console.log(chalk.green(`Installed ${source}`)), !0;
+      case "remove":
+        return await packageManager.removeAndPersist(source, { local: options.local }) ? (console.log(chalk.green(`Removed ${source}`)), !0) : (console.error(chalk.red(`No matching package found for ${source}`)), process.exitCode = 1, !0);
+      case "list": {
+        let configuredPackages = packageManager.listConfiguredPackages(), userPackages = configuredPackages.filter((pkg) => pkg.scope === "user"), projectPackages = configuredPackages.filter((pkg) => pkg.scope === "project");
+        if (configuredPackages.length === 0)
+          return console.log(chalk.dim("No packages installed.")), !0;
+        let formatPackage = (pkg) => {
+          let display = pkg.filtered ? `${pkg.source} (filtered)` : pkg.source;
+          console.log(`  ${display}`), pkg.installedPath && console.log(chalk.dim(`    ${pkg.installedPath}`));
+        };
+        if (userPackages.length > 0) {
+          console.log(chalk.bold("User packages:"));
+          for (let pkg of userPackages)
+            formatPackage(pkg);
+        }
+        if (projectPackages.length > 0) {
+          userPackages.length > 0 && console.log(), console.log(chalk.bold("Project packages:"));
+          for (let pkg of projectPackages)
+            formatPackage(pkg);
+        }
+        return !0;
+      }
+    }
+  } catch (error) {
+    let message = error instanceof Error ? error.message : "Unknown package command error";
+    return console.error(chalk.red(`Error: ${message}`)), process.exitCode = 1, !0;
+  }
+}
+export {
+  handleConfigCommand,
+  handlePackageCommand
+};