@iowarp/clio-coder 0.4.1 → 0.4.3

package/dist/chunk-SUW5DORT.js

@@ -1,819 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  getVersionInfo
-} from "./chunk-XPLRXC72.js";
-import {
-  require_dist
-} from "./chunk-APJ265NV.js";
-import {
-  clioConfigDir
-} from "./chunk-BYP5D4HI.js";
-import {
-  safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-3R73A4XB.js";
-
-// src/domains/extensions/discovery.ts
-init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
-import path from "node:path";
-
-// src/domains/extensions/compatibility.ts
-init_esm_shims();
-var MAX_RANGE_CHARS = 256;
-var NUMERIC = "(?:0|[1-9]\\d*)";
-var IDENTIFIER = "[0-9A-Za-z-]+";
-var VERSION_RE = new RegExp(
-  `^v?(${NUMERIC})\\.(${NUMERIC})\\.(${NUMERIC})(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
-);
-var PARTIAL_RE = new RegExp(
-  `^v?(${NUMERIC}|[xX*])(?:\\.(${NUMERIC}|[xX*]))?(?:\\.(${NUMERIC}|[xX*]))?(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
-);
-function prerelease(value) {
-  if (value === void 0) return [];
-  const out = [];
-  for (const identifier of value.split(".")) {
-    if (identifier.length === 0) return null;
-    if (/^\d+$/u.test(identifier)) {
-      if (identifier.length > 1 && identifier.startsWith("0")) return null;
-      const parsed = Number(identifier);
-      if (!Number.isSafeInteger(parsed)) return null;
-      out.push(parsed);
-    } else {
-      out.push(identifier);
-    }
-  }
-  return out;
-}
-function parseSemVer(value) {
-  const match = VERSION_RE.exec(value);
-  if (match === null) return null;
-  const parsedPrerelease = prerelease(match[4]);
-  if (parsedPrerelease === null) return null;
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  const patch = Number(match[3]);
-  if (![major, minor, patch].every(Number.isSafeInteger)) return null;
-  return { major, minor, patch, prerelease: parsedPrerelease };
-}
-function parsePart(value) {
-  if (value === void 0 || value === "x" || value === "X" || value === "*") return null;
-  const parsed = Number(value);
-  return Number.isSafeInteger(parsed) ? parsed : null;
-}
-function parsePartial(value) {
-  const match = PARTIAL_RE.exec(value);
-  if (match === null) return null;
-  for (const part of match.slice(1, 4)) {
-    if (part === void 0 || part === "x" || part === "X" || part === "*") continue;
-    if (!Number.isSafeInteger(Number(part))) return null;
-  }
-  const major = parsePart(match[1]);
-  const minor = parsePart(match[2]);
-  const patch = parsePart(match[3]);
-  if (major === null && (match[2] !== void 0 || match[3] !== void 0) || minor === null && match[3] !== void 0) {
-    return null;
-  }
-  const parsedPrerelease = prerelease(match[4]);
-  if (parsedPrerelease === null) return null;
-  if (parsedPrerelease.length > 0 && (major === null || minor === null || patch === null)) return null;
-  return { major, minor, patch, prerelease: parsedPrerelease };
-}
-function compareIdentifiers(left, right) {
-  if (left === right) return 0;
-  if (typeof left === "number" && typeof right === "number") return left < right ? -1 : 1;
-  if (typeof left === "number") return -1;
-  if (typeof right === "number") return 1;
-  return left < right ? -1 : 1;
-}
-function compare(left, right) {
-  for (const key of ["major", "minor", "patch"]) {
-    if (left[key] !== right[key]) return left[key] < right[key] ? -1 : 1;
-  }
-  if (left.prerelease.length === 0 || right.prerelease.length === 0) {
-    if (left.prerelease.length === right.prerelease.length) return 0;
-    return left.prerelease.length === 0 ? 1 : -1;
-  }
-  const length = Math.max(left.prerelease.length, right.prerelease.length);
-  for (let index = 0; index < length; index += 1) {
-    const leftPart = left.prerelease[index];
-    const rightPart = right.prerelease[index];
-    if (leftPart === void 0 || rightPart === void 0) {
-      if (leftPart === rightPart) return 0;
-      return leftPart === void 0 ? -1 : 1;
-    }
-    const order = compareIdentifiers(leftPart, rightPart);
-    if (order !== 0) return order;
-  }
-  return 0;
-}
-function floor(partial) {
-  return {
-    major: partial.major ?? 0,
-    minor: partial.minor ?? 0,
-    patch: partial.patch ?? 0,
-    prerelease: partial.prerelease
-  };
-}
-function nextWildcard(partial) {
-  if (partial.major === null) return null;
-  if (partial.minor === null) return { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] };
-  if (partial.patch === null) return { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
-  return null;
-}
-function lowerBound(version, inclusive) {
-  return (candidate) => inclusive ? compare(candidate, version) >= 0 : compare(candidate, version) > 0;
-}
-function upperBound(version, inclusive) {
-  return (candidate) => inclusive ? compare(candidate, version) <= 0 : compare(candidate, version) < 0;
-}
-function core(version) {
-  return `${version.major}.${version.minor}.${version.patch}`;
-}
-function predicatesForToken(token) {
-  const match = /^(<=|>=|<|>|=|~|\^)?(.+)$/u.exec(token);
-  if (match === null) return null;
-  const operator = match[1] ?? "";
-  const partial = parsePartial(match[2] ?? "");
-  if (partial === null) return null;
-  const base = floor(partial);
-  const wildcardUpper = nextWildcard(partial);
-  const prereleaseCore = partial.prerelease.length > 0 ? core(base) : null;
-  if (operator === "" || operator === "=") {
-    if (partial.major === null) return { predicates: [], prereleaseCore };
-    if (wildcardUpper !== null) {
-      return { predicates: [lowerBound(base, true), upperBound(wildcardUpper, false)], prereleaseCore };
-    }
-    return { predicates: [(candidate) => compare(candidate, base) === 0], prereleaseCore };
-  }
-  if (operator === ">=") return { predicates: [lowerBound(base, true)], prereleaseCore };
-  if (operator === "<") return { predicates: [upperBound(base, false)], prereleaseCore };
-  if (operator === ">") {
-    return {
-      predicates: [wildcardUpper === null ? lowerBound(base, false) : lowerBound(wildcardUpper, true)],
-      prereleaseCore
-    };
-  }
-  if (operator === "<=") {
-    return {
-      predicates: [wildcardUpper === null ? upperBound(base, true) : upperBound(wildcardUpper, false)],
-      prereleaseCore
-    };
-  }
-  if (partial.major === null) return { predicates: [], prereleaseCore };
-  if (operator === "~") {
-    const upper2 = partial.minor === null ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
-    return { predicates: [lowerBound(base, true), upperBound(upper2, false)], prereleaseCore };
-  }
-  const upper = partial.major > 0 ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : partial.minor === null ? { major: 1, minor: 0, patch: 0, prerelease: [] } : (partial.minor ?? 0) > 0 ? { major: 0, minor: (partial.minor ?? 0) + 1, patch: 0, prerelease: [] } : partial.patch === null ? { major: 0, minor: 1, patch: 0, prerelease: [] } : { major: 0, minor: 0, patch: (partial.patch ?? 0) + 1, prerelease: [] };
-  return { predicates: [lowerBound(base, true), upperBound(upper, false)], prereleaseCore };
-}
-function predicatesForSet(raw) {
-  const hyphen = /^(\S+)\s+-\s+(\S+)$/u.exec(raw);
-  if (hyphen !== null) {
-    const left = parsePartial(hyphen[1] ?? "");
-    const right = parsePartial(hyphen[2] ?? "");
-    if (left === null || right === null || left.major === null || right.major === null) return null;
-    const rightUpper = nextWildcard(right);
-    return {
-      predicates: [
-        lowerBound(floor(left), true),
-        rightUpper === null ? upperBound(floor(right), true) : upperBound(rightUpper, false)
-      ],
-      prereleaseCores: new Set(
-        [
-          left.prerelease.length > 0 ? core(floor(left)) : null,
-          right.prerelease.length > 0 ? core(floor(right)) : null
-        ].filter((entry) => entry !== null)
-      )
-    };
-  }
-  const normalized = raw.replace(/(<=|>=|<|>|=|~|\^)\s+/gu, "$1");
-  const tokens = normalized.split(/\s+/u).filter((entry) => entry.length > 0);
-  if (tokens.length === 0) return null;
-  const predicates = [];
-  const prereleaseCores = /* @__PURE__ */ new Set();
-  for (const token of tokens) {
-    const parsed = predicatesForToken(token);
-    if (parsed === null) return null;
-    predicates.push(...parsed.predicates);
-    if (parsed.prereleaseCore !== null) prereleaseCores.add(parsed.prereleaseCore);
-  }
-  return { predicates, prereleaseCores };
-}
-function parseRange(range) {
-  const trimmed = range.trim();
-  if (trimmed.length === 0 || trimmed.length > MAX_RANGE_CHARS) return null;
-  const sets = trimmed.split("||");
-  if (sets.some((set) => set.trim().length === 0)) return null;
-  const parsed = sets.map((set) => predicatesForSet(set.trim()));
-  return parsed.every((set) => set !== null) ? parsed : null;
-}
-function isValidSemVerRange(range) {
-  return parseRange(range) !== null;
-}
-function satisfiesSemVerRange(version, range) {
-  const candidate = parseSemVer(version);
-  const sets = parseRange(range);
-  if (candidate === null || sets === null) return false;
-  return sets.some((set) => {
-    if (candidate.prerelease.length > 0 && !set.prereleaseCores.has(core(candidate))) return false;
-    return set.predicates.every((predicate) => predicate(candidate));
-  });
-}
-function evaluateClioCompatibility(range, runningVersion = getVersionInfo().clio) {
-  const rangeValid = isValidSemVerRange(range);
-  return {
-    rangeValid,
-    satisfied: rangeValid && satisfiesSemVerRange(runningVersion, range),
-    runningVersion
-  };
-}
-
-// src/domains/extensions/discovery.ts
-var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function trimString(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : void 0;
-}
-function validateId(id) {
-  if (id.length > 80) return "id exceeds 80 characters";
-  if (!/^[a-z0-9][a-z0-9._-]*[a-z0-9]$/.test(id)) {
-    return "id must use lowercase letters, numbers, dots, underscores, or hyphens and start/end alphanumeric";
-  }
-  return null;
-}
-function readJsonOrYaml(filePath) {
-  const raw = readFileSync(filePath, "utf8");
-  if (filePath.endsWith(".json")) return JSON.parse(raw);
-  return (0, import_yaml.parse)(raw);
-}
-function normalizeResources(value) {
-  if (!isRecord(value)) return {};
-  const out = {};
-  const skills = trimString(value.skills);
-  const prompts = trimString(value.prompts);
-  const agents = trimString(value.agents);
-  const fleets = trimString(value.fleets);
-  const themes = trimString(value.themes);
-  if (skills) out.skills = skills;
-  if (prompts) out.prompts = prompts;
-  if (agents) out.agents = agents;
-  if (fleets) out.fleets = fleets;
-  if (themes) out.themes = themes;
-  return out;
-}
-function contained(root, candidate) {
-  const relative = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative);
-}
-function validateResourceTree(root, resourcePath, kind, diagnostics) {
-  if (path.isAbsolute(resourcePath)) {
-    diagnostics.push({ type: "error", message: `resources.${kind} must be relative`, path: resourcePath });
-    return;
-  }
-  const resolvedRoot = path.resolve(root);
-  const resolved = path.resolve(resolvedRoot, resourcePath);
-  if (!contained(resolvedRoot, resolved) || resolved === resolvedRoot) {
-    diagnostics.push({ type: "error", message: `resources.${kind} escapes the extension root`, path: resourcePath });
-    return;
-  }
-  let canonicalRoot;
-  let canonicalResource;
-  try {
-    canonicalRoot = realpathSync(resolvedRoot);
-    canonicalResource = realpathSync(resolved);
-    if (!lstatSync(resolved).isDirectory()) {
-      diagnostics.push({ type: "error", message: `resources.${kind} is not a directory`, path: resolved });
-      return;
-    }
-  } catch (error) {
-    diagnostics.push({
-      type: "error",
-      message: `resources.${kind} cannot be resolved: ${error instanceof Error ? error.message : String(error)}`,
-      path: resolved
-    });
-    return;
-  }
-  if (!contained(canonicalRoot, canonicalResource)) {
-    diagnostics.push({ type: "error", message: `resources.${kind} escapes through a symbolic link`, path: resolved });
-    return;
-  }
-  const pending = [resolved];
-  while (pending.length > 0) {
-    const directory = pending.pop();
-    if (!directory) continue;
-    for (const entry of readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const candidate = path.join(directory, entry.name);
-      if (entry.isSymbolicLink()) {
-        try {
-          if (!contained(canonicalRoot, realpathSync(candidate))) {
-            diagnostics.push({
-              type: "error",
-              message: `resources.${kind} contains an escaping symbolic link`,
-              path: candidate
-            });
-          }
-        } catch (error) {
-          diagnostics.push({
-            type: "error",
-            message: `resources.${kind} contains an unresolved symbolic link: ${error instanceof Error ? error.message : String(error)}`,
-            path: candidate
-          });
-        }
-      } else if (entry.isDirectory()) {
-        pending.push(candidate);
-      }
-    }
-  }
-}
-function validateResourceRoots(root, resources, diagnostics) {
-  for (const [kind, resourcePath] of Object.entries(resources)) {
-    if (resourcePath) validateResourceTree(root, resourcePath, kind, diagnostics);
-  }
-}
-function stringArray(value) {
-  if (!Array.isArray(value)) return void 0;
-  const out = value.map((entry) => trimString(entry)).filter((entry) => entry !== void 0);
-  return out.length > 0 ? out : void 0;
-}
-function parseExtensionManifest(value, manifestPath) {
-  const diagnostics = [];
-  if (!isRecord(value)) {
-    return { diagnostics: [{ type: "error", message: "extension manifest must be an object", path: manifestPath }] };
-  }
-  if (value.manifestVersion !== 1) {
-    diagnostics.push({ type: "error", message: "manifestVersion must be 1", path: manifestPath });
-  }
-  const id = trimString(value.id);
-  const name = trimString(value.name) ?? id;
-  const version = trimString(value.version);
-  const description = trimString(value.description);
-  if (!id) diagnostics.push({ type: "error", message: "id is required", path: manifestPath });
-  else {
-    const idError = validateId(id);
-    if (idError) diagnostics.push({ type: "error", message: idError, path: manifestPath });
-  }
-  if (!version) diagnostics.push({ type: "error", message: "version is required", path: manifestPath });
-  if (!description) diagnostics.push({ type: "error", message: "description is required", path: manifestPath });
-  const resources = normalizeResources(value.resources);
-  const tools = stringArray(value.tools);
-  const settings = stringArray(value.settings);
-  let compatibility;
-  if (value.compatibility !== void 0) {
-    if (!isRecord(value.compatibility)) {
-      diagnostics.push({ type: "error", message: "compatibility must be an object", path: manifestPath });
-    } else if ("clio" in value.compatibility) {
-      const range = trimString(value.compatibility.clio);
-      if (range === void 0) {
-        diagnostics.push({
-          type: "error",
-          message: "compatibility.clio must be a non-empty semver range",
-          path: manifestPath
-        });
-      } else {
-        const evaluation = evaluateClioCompatibility(range);
-        if (!evaluation.rangeValid) {
-          diagnostics.push({
-            type: "error",
-            message: `extension ${id ?? "<unknown>"} declares malformed compatibility.clio range '${range}'`,
-            path: manifestPath
-          });
-        } else {
-          compatibility = { clio: range };
-        }
-      }
-    }
-  }
-  if (!id || !name || !version || !description || diagnostics.some((diag) => diag.type === "error")) {
-    return { diagnostics };
-  }
-  const manifest = {
-    manifestVersion: 1,
-    id,
-    name,
-    version,
-    description,
-    resources
-  };
-  if (tools) manifest.tools = tools;
-  if (settings) manifest.settings = settings;
-  if (compatibility && Object.keys(compatibility).length > 0) manifest.compatibility = compatibility;
-  const clioRange = manifest.compatibility?.clio;
-  if (clioRange !== void 0) {
-    const evaluation = evaluateClioCompatibility(clioRange);
-    if (!evaluation.satisfied) {
-      diagnostics.push({
-        type: "error",
-        message: `extension ${manifest.id} requires Clio '${clioRange}', but running Clio version is '${evaluation.runningVersion}'`,
-        path: manifestPath
-      });
-    }
-  }
-  return { manifest, diagnostics };
-}
-function findExtensionManifestPath(root) {
-  for (const name of MANIFEST_NAMES) {
-    const candidate = path.join(root, name);
-    try {
-      if (statSync(candidate).isFile()) return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function loadManifestFromRoot(root) {
-  const manifestPath = findExtensionManifestPath(root);
-  if (!manifestPath) {
-    return {
-      path: root,
-      valid: false,
-      diagnostics: [{ type: "error", message: "extension manifest not found", path: root }]
-    };
-  }
-  try {
-    const parsed = parseExtensionManifest(readJsonOrYaml(manifestPath), manifestPath);
-    if (parsed.manifest) validateResourceRoots(root, parsed.manifest.resources, parsed.diagnostics);
-    return {
-      path: root,
-      manifestPath,
-      ...parsed.manifest ? { manifest: parsed.manifest } : {},
-      valid: parsed.manifest !== void 0 && !parsed.diagnostics.some((diag) => diag.type === "error"),
-      diagnostics: parsed.diagnostics
-    };
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    return {
-      path: root,
-      manifestPath,
-      valid: false,
-      diagnostics: [{ type: "error", message: `extension manifest could not be read: ${reason}`, path: manifestPath }]
-    };
-  }
-}
-function discoverExtensionPackages(root) {
-  const full = path.resolve(root);
-  if (!existsSync(full)) {
-    return [{ path: full, valid: false, diagnostics: [{ type: "error", message: "path does not exist", path: full }] }];
-  }
-  const stat = statSync(full);
-  if (!stat.isDirectory()) {
-    return [
-      {
-        path: full,
-        valid: false,
-        diagnostics: [{ type: "error", message: "extension path is not a directory", path: full }]
-      }
-    ];
-  }
-  const direct = loadManifestFromRoot(full);
-  if (direct.valid || direct.manifestPath) return [direct];
-  const candidates = [];
-  for (const entry of readdirSync(full, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-    const child = path.join(full, entry.name);
-    const loaded = loadManifestFromRoot(child);
-    if (loaded.valid || loaded.manifestPath) candidates.push(loaded);
-  }
-  const discovered = candidates.length > 0 ? candidates : [direct];
-  const ids = /* @__PURE__ */ new Map();
-  for (const candidate of discovered) {
-    const id = candidate.manifest?.id;
-    if (!id) continue;
-    const group = ids.get(id) ?? [];
-    group.push(candidate);
-    ids.set(id, group);
-  }
-  for (const [id, group] of ids) {
-    if (group.length < 2) continue;
-    for (const candidate of group) {
-      candidate.valid = false;
-      candidate.diagnostics.push({
-        type: "error",
-        message: `duplicate extension id ${id}`,
-        path: candidate.manifestPath ?? candidate.path
-      });
-    }
-  }
-  return discovered;
-}
-
-// src/domains/extensions/state.ts
-init_esm_shims();
-import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, renameSync, rmSync } from "node:fs";
-import path2 from "node:path";
-var DEFAULT_STATE = { version: 1, disabled: [], installed: {} };
-function extensionBaseDir(scope, cwd = process.cwd()) {
-  return scope === "user" ? path2.join(clioConfigDir(), "extensions") : path2.join(path2.resolve(cwd), ".clio-coder", "extensions");
-}
-function statePath(scope, cwd = process.cwd()) {
-  return path2.join(extensionBaseDir(scope, cwd), "state.json");
-}
-function scopeRank(scope) {
-  return scope === "project" ? 2 : 1;
-}
-function readState(scope, cwd = process.cwd()) {
-  const filePath = statePath(scope, cwd);
-  if (!existsSync2(filePath)) return structuredClone(DEFAULT_STATE);
-  try {
-    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
-    if (!isRecord(parsed) || parsed.version !== 1) return structuredClone(DEFAULT_STATE);
-    const disabled = Array.isArray(parsed.disabled) ? parsed.disabled.filter((entry) => typeof entry === "string") : [];
-    const installed = isRecord(parsed.installed) ? Object.fromEntries(
-      Object.entries(parsed.installed).flatMap(([id, raw]) => {
-        if (!isRecord(raw)) return [];
-        const installedAt = trimString(raw.installedAt) ?? (/* @__PURE__ */ new Date(0)).toISOString();
-        const source = trimString(raw.source);
-        return [[id, { installedAt, ...source ? { source } : {} }]];
-      })
-    ) : {};
-    return { version: 1, disabled, installed };
-  } catch {
-    return structuredClone(DEFAULT_STATE);
-  }
-}
-function writeState(scope, state, cwd = process.cwd()) {
-  const filePath = statePath(scope, cwd);
-  safeResourceWrite(filePath, `${JSON.stringify(state, null, 2)}
-`, { encoding: "utf8" });
-}
-function installedFromRoot(root, scope, state) {
-  const candidate = loadManifestFromRoot(root);
-  const manifest = candidate.manifest;
-  if (!manifest || !candidate.manifestPath) return null;
-  const clioRange = manifest.compatibility?.clio;
-  const compatible = clioRange === void 0 || evaluateClioCompatibility(clioRange).satisfied;
-  return {
-    id: manifest.id,
-    name: manifest.name,
-    version: manifest.version,
-    description: manifest.description,
-    scope,
-    rootPath: root,
-    manifestPath: candidate.manifestPath,
-    enabled: !state.disabled.includes(manifest.id),
-    compatible,
-    effective: false,
-    resources: manifest.resources,
-    diagnostics: candidate.diagnostics
-  };
-}
-function listScope(scope, cwd = process.cwd()) {
-  const base = extensionBaseDir(scope, cwd);
-  if (!existsSync2(base)) return [];
-  const state = readState(scope, cwd);
-  const out = [];
-  for (const entry of readdirSync2(base, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-    if (!entry.isDirectory()) continue;
-    const root = path2.join(base, entry.name);
-    const installed = installedFromRoot(root, scope, state);
-    if (installed) out.push(installed);
-  }
-  return out;
-}
-function listInstalledExtensions(cwd = process.cwd(), options = {}) {
-  const scopes = options.scope ? [options.scope] : ["user", "project"];
-  const entries = scopes.flatMap((scope) => listScope(scope, cwd));
-  const byId = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const list = byId.get(entry.id) ?? [];
-    list.push(entry);
-    byId.set(entry.id, list);
-  }
-  for (const group of byId.values()) {
-    const winner = group.filter((entry) => entry.compatible).sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1);
-    for (const entry of group) {
-      entry.effective = entry === winner;
-      if (entry.compatible && !entry.effective && winner) entry.overriddenBy = winner.scope;
-    }
-  }
-  const all = options.all === true ? entries : entries.filter((entry) => entry.effective || !entry.compatible);
-  return all.sort((a, b) => {
-    const id = a.id.localeCompare(b.id);
-    if (id !== 0) return id;
-    return scopeRank(a.scope) - scopeRank(b.scope);
-  });
-}
-function findInstalled(id, cwd, scope) {
-  const entries = listInstalledExtensions(cwd, { ...scope ? { scope } : {}, all: true }).filter(
-    (entry) => entry.id === id
-  );
-  if (entries.length === 0) return null;
-  return [...entries].sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1) ?? null;
-}
-function installExtension(sourcePath, options = {}) {
-  const scope = options.scope ?? "user";
-  const cwd = options.cwd ?? process.cwd();
-  const source = path2.resolve(sourcePath);
-  const candidate = loadManifestFromRoot(source);
-  if (!candidate.manifest || !candidate.valid) return { diagnostics: candidate.diagnostics };
-  const targetRoot = path2.join(extensionBaseDir(scope, cwd), candidate.manifest.id);
-  if (existsSync2(targetRoot)) {
-    if (!options.force) {
-      return {
-        diagnostics: [
-          { type: "error", message: `extension ${candidate.manifest.id} is already installed`, path: targetRoot }
-        ]
-      };
-    }
-  }
-  const parent = path2.dirname(targetRoot);
-  const stagingRoot = path2.join(parent, `.${candidate.manifest.id}.install-${process.pid}-${Date.now()}`);
-  const backupRoot = path2.join(parent, `.${candidate.manifest.id}.backup-${process.pid}-${Date.now()}`);
-  let installedReplacement = false;
-  let movedExisting = false;
-  const state = readState(scope, cwd);
-  try {
-    mkdirSync(parent, { recursive: true });
-    rmSync(stagingRoot, { recursive: true, force: true });
-    rmSync(backupRoot, { recursive: true, force: true });
-    cpSync(source, stagingRoot, {
-      recursive: true,
-      // `state.json` beside the installed extension directories belongs to
-      // Clio's extension manager. An extension may legitimately ship nested
-      // resources with the same basename (for example a project-state JSON
-      // template), so exclude only a bookkeeping file at the package root.
-      filter: (src) => path2.relative(source, src) !== "state.json"
-    });
-    if (existsSync2(targetRoot)) {
-      renameSync(targetRoot, backupRoot);
-      movedExisting = true;
-    }
-    renameSync(stagingRoot, targetRoot);
-    installedReplacement = true;
-    state.installed[candidate.manifest.id] = { installedAt: (/* @__PURE__ */ new Date()).toISOString(), source };
-    state.disabled = state.disabled.filter((entry) => entry !== candidate.manifest?.id);
-    writeState(scope, state, cwd);
-    rmSync(backupRoot, { recursive: true, force: true });
-  } catch (error) {
-    rmSync(stagingRoot, { recursive: true, force: true });
-    if (installedReplacement) rmSync(targetRoot, { recursive: true, force: true });
-    if (movedExisting && existsSync2(backupRoot) && !existsSync2(targetRoot)) {
-      renameSync(backupRoot, targetRoot);
-    }
-    return {
-      diagnostics: [
-        {
-          type: "error",
-          message: `extension ${candidate.manifest.id} install failed: ${error instanceof Error ? error.message : String(error)}`,
-          path: targetRoot
-        }
-      ]
-    };
-  }
-  const installed = findInstalled(candidate.manifest.id, cwd, scope);
-  return {
-    ...installed ? { extension: installed } : {},
-    diagnostics: candidate.diagnostics
-  };
-}
-function mutateEnabled(id, enabled, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const target = findInstalled(id, cwd, options.scope);
-  if (!target) {
-    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
-  }
-  const state = readState(target.scope, cwd);
-  if (enabled) state.disabled = state.disabled.filter((entry) => entry !== id);
-  else if (!state.disabled.includes(id)) state.disabled.push(id);
-  writeState(target.scope, state, cwd);
-  const extension = findInstalled(id, cwd, target.scope) ?? void 0;
-  return { ...extension ? { extension } : {}, diagnostics: [] };
-}
-function enableExtension(id, options = {}) {
-  return mutateEnabled(id, true, options);
-}
-function disableExtension(id, options = {}) {
-  return mutateEnabled(id, false, options);
-}
-function removeExtension(id, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const target = findInstalled(id, cwd, options.scope);
-  if (!target) {
-    return { diagnostics: [{ type: "error", message: `extension ${id} is not installed` }] };
-  }
-  rmSync(target.rootPath, { recursive: true, force: true });
-  const state = readState(target.scope, cwd);
-  Reflect.deleteProperty(state.installed, id);
-  state.disabled = state.disabled.filter((entry) => entry !== id);
-  writeState(target.scope, state, cwd);
-  return { removed: { id, scope: target.scope, path: target.rootPath }, diagnostics: [] };
-}
-
-// src/domains/extensions/manager.ts
-init_esm_shims();
-
-// src/domains/extensions/resources.ts
-init_esm_shims();
-import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
-import path3 from "node:path";
-function extensionResourcePath(rootPath, resourcePath) {
-  const root = path3.resolve(rootPath);
-  const full = path3.resolve(root, resourcePath);
-  const relative = path3.relative(root, full);
-  if (relative === "" || relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative))
-    return null;
-  try {
-    const rootReal = realpathSync2(root);
-    const fullReal = realpathSync2(full);
-    const canonicalRelative = path3.relative(rootReal, fullReal);
-    if (canonicalRelative === ".." || canonicalRelative.startsWith(`..${path3.sep}`) || path3.isAbsolute(canonicalRelative)) {
-      return null;
-    }
-    if (!lstatSync2(full).isDirectory()) return null;
-    return full;
-  } catch {
-    return null;
-  }
-}
-function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
-  const roots = [];
-  for (const entry of listInstalledExtensions(cwd)) {
-    if (!entry.enabled || !entry.compatible || !entry.effective) continue;
-    const rel = entry.resources[kind];
-    if (!rel) continue;
-    const full = extensionResourcePath(entry.rootPath, rel);
-    if (!full) continue;
-    roots.push({
-      id: entry.id,
-      scope: entry.scope,
-      path: full,
-      rootPath: entry.rootPath,
-      source: `extension:${entry.scope}:${entry.id}`
-    });
-  }
-  return roots;
-}
-
-// src/domains/extensions/index.ts
-init_esm_shims();
-
-// src/domains/extensions/extension.ts
-init_esm_shims();
-function createExtensionsBundle(_context) {
-  const extension = {
-    start() {
-      return void 0;
-    }
-  };
-  const contract = {
-    list(cwd, options = {}) {
-      return listInstalledExtensions(cwd, options);
-    },
-    discover(root) {
-      return discoverExtensionPackages(root);
-    },
-    install(root, options = {}) {
-      return installExtension(root, options);
-    },
-    enable(id, options = {}) {
-      return enableExtension(id, options);
-    },
-    disable(id, options = {}) {
-      return disableExtension(id, options);
-    },
-    remove(id, options = {}) {
-      return removeExtension(id, options);
-    },
-    resourceRoots(kind, cwd) {
-      return enabledExtensionResourceRoots(kind, cwd);
-    },
-    async reload() {
-      return void 0;
-    }
-  };
-  return { extension, contract };
-}
-
-// src/domains/extensions/manifest.ts
-init_esm_shims();
-var ExtensionsManifest = {
-  name: "extensions",
-  dependsOn: ["config"]
-};
-
-// src/domains/extensions/index.ts
-var ExtensionsDomainModule = {
-  manifest: ExtensionsManifest,
-  createExtension: createExtensionsBundle
-};
-
-export {
-  discoverExtensionPackages,
-  listInstalledExtensions,
-  installExtension,
-  enableExtension,
-  disableExtension,
-  removeExtension,
-  enabledExtensionResourceRoots,
-  ExtensionsDomainModule
-};
-//# sourceMappingURL=chunk-SUW5DORT.js.map