@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-ZARZ4POR.js

@@ -0,0 +1,210 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  loadSkills,
+  parseAgentRecipeSchema,
+  recipeIdFromPath
+} from "./chunk-LAR7DX5E.js";
+import {
+  enabledPluginResourceRoots,
+  parseFrontmatter,
+  resolvePackageReferences
+} from "./chunk-NVPXXW2H.js";
+import {
+  assertAgentSpecPolicy,
+  isShadowAgent,
+  normalizeAgentSpec
+} from "./chunk-LNOXCGN2.js";
+import {
+  readSettings
+} from "./chunk-56XP4FJU.js";
+import {
+  clioConfigDir
+} from "./chunk-CTTI7G3T.js";
+import {
+  resolvePackageRoot
+} from "./chunk-ZPST2KQO.js";
+import {
+  writeDiagnostic
+} from "./chunk-FD2I4KBR.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/agents/registry.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+var RESERVED_CUSTOM_AGENT_IDS = /* @__PURE__ */ new Set(["worker", "delegate", "auto"]);
+var MAX_AGENT_RECIPE_DIAGNOSTICS = 256;
+function recordDiagnostic(diagnostics, diagnostic) {
+  if (diagnostics.length < MAX_AGENT_RECIPE_DIAGNOSTICS) diagnostics.push(diagnostic);
+}
+function resolveBoundSkills(recipe, source) {
+  if (recipe.skills.length === 0) return { ...recipe, boundSkillPaths: [] };
+  const packageSkills = path.resolve(source.dir, "..", "..", "..", "..", "library", "skills");
+  if (source.source === "plugin" && source.skillRoot === void 0) {
+    throw new Error(
+      `agent recipe: ${recipe.filepath}: ${source.source} declares bound skills but no skills resource root`
+    );
+  }
+  const skills = source.source === "plugin" ? loadSkills({
+    cwd: source.cwd ?? process.cwd(),
+    trustProjectCompatRoots: readSettings().integrations.projectResources.trustProjectImports,
+    disableDiscovery: true,
+    explicitSkillPaths: source.skillRoot === void 0 ? [] : [source.skillRoot]
+  }) : loadSkills({
+    cwd: source.cwd ?? process.cwd(),
+    trustProjectCompatRoots: readSettings().integrations.projectResources.trustProjectImports,
+    ...source.source === "builtin" && existsSync(packageSkills) ? { explicitSkillPaths: [packageSkills] } : {}
+  });
+  if (source.source === "plugin" && source.skillRoot !== void 0) {
+    const canonicalRoot = realpathSync(source.skillRoot);
+    for (const skill of skills.items) {
+      const relative = path.relative(canonicalRoot, realpathSync(skill.filePath));
+      if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`agent recipe: ${recipe.filepath}: bound skill escapes its ${source.source}: ${skill.filePath}`);
+      }
+    }
+  }
+  const byName = new Map(skills.items.filter((skill) => skill.trusted).map((skill) => [skill.name, skill.filePath]));
+  const missing = recipe.skills.filter((skill) => !byName.has(skill));
+  if (missing.length > 0) {
+    throw new Error(`agent recipe: ${recipe.filepath}: bound skill(s) unavailable: ${missing.join(", ")}`);
+  }
+  const boundSkillPaths = recipe.skills.map((skill) => {
+    const filePath = byName.get(skill);
+    if (filePath === void 0) throw new Error(`agent recipe: ${recipe.filepath}: bound skill unavailable: ${skill}`);
+    return filePath;
+  });
+  return { ...recipe, boundSkillPaths };
+}
+function loadRecipesFromDir(source, diagnostics = []) {
+  let entries;
+  try {
+    entries = readdirSync(source.dir, { withFileTypes: true });
+  } catch (err) {
+    const error = err;
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return [];
+    throw err;
+  }
+  const recipes = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filepath = path.join(source.dir, entry.name);
+    try {
+      const id = recipeIdFromPath(filepath, source.dir);
+      const raw = readFileSync(filepath, "utf8");
+      const { frontmatter, body: rawBody } = parseFrontmatter(raw, filepath);
+      const body = resolvePackageReferences(rawBody, {
+        ...source.rootPath ? { rootPath: source.rootPath } : {},
+        plugin: source.source === "plugin"
+      });
+      const parsedRecipe = parseAgentRecipeSchema({ id, source: source.source, filepath, body, frontmatter });
+      const recipe = resolveBoundSkills(parsedRecipe, source);
+      assertAgentSpecPolicy(normalizeAgentSpec(recipe));
+      recipes.push(recipe);
+    } catch (error) {
+      if (source.source === "builtin") throw error;
+      const message = error instanceof Error ? error.message : String(error);
+      recordDiagnostic(diagnostics, { kind: "quarantine", source: source.source, filepath, message });
+      writeDiagnostic(`[clio-coder:agents] quarantine path=${filepath} source=${source.source} reason=${message}
+`);
+    }
+  }
+  recipes.sort((left, right) => left.id.localeCompare(right.id));
+  return recipes;
+}
+function mergeRecipes(diagnostics, ...sources) {
+  const ignored = (recipe, reason) => {
+    writeDiagnostic(`[clio-coder:agents] ignore id=${recipe.id} by=${recipe.source} reason=${reason}
+`);
+    recordDiagnostic(diagnostics, {
+      kind: "ignored",
+      id: recipe.id,
+      source: recipe.source,
+      audience: recipe.audience,
+      filepath: recipe.filepath,
+      message: `agent recipe ${recipe.id} from ${recipe.source} ignored: ${reason}`
+    });
+  };
+  const byId = /* @__PURE__ */ new Map();
+  const builtinById = /* @__PURE__ */ new Map();
+  for (const group of sources) {
+    for (const recipe of group) {
+      if (recipe.source === "builtin") builtinById.set(recipe.id, recipe);
+    }
+  }
+  for (const group of sources) {
+    for (const recipe of group) {
+      if (recipe.source !== "builtin" && RESERVED_CUSTOM_AGENT_IDS.has(recipe.id)) {
+        ignored(recipe, "reserved-agent-id");
+        continue;
+      }
+      const builtin = builtinById.get(recipe.id);
+      if (recipe.source === "plugin" && builtin) {
+        ignored(recipe, "reserved-builtin");
+        continue;
+      }
+      if (recipe.source === "user" && builtin && isShadowAgent(normalizeAgentSpec(builtin))) {
+        ignored(recipe, "reserved-shadow");
+        continue;
+      }
+      if (recipe.source === "project" && builtin) {
+        ignored(recipe, "reserved-builtin");
+        continue;
+      }
+      const previous = byId.get(recipe.id);
+      if (previous) {
+        writeDiagnostic(`[clio-coder:agents] override id=${recipe.id} by=${recipe.source}
+`);
+        recordDiagnostic(diagnostics, {
+          kind: "overridden",
+          id: previous.id,
+          source: previous.source,
+          audience: previous.audience,
+          by: recipe.source,
+          filepath: previous.filepath,
+          message: `agent recipe ${previous.id} from ${previous.source} overridden by ${recipe.source}`
+        });
+      }
+      byId.set(recipe.id, recipe);
+    }
+  }
+  return Array.from(byId.values()).sort((left, right) => left.id.localeCompare(right.id));
+}
+function discoverAgentRecipes(cwd = process.cwd(), diagnostics = []) {
+  const builtin = loadRecipesFromDir(
+    {
+      dir: path.join(resolvePackageRoot(), "src", "domains", "agents", "builtins"),
+      source: "builtin",
+      cwd
+    },
+    diagnostics
+  );
+  const skillRoots = new Map(enabledPluginResourceRoots("skills", cwd).map((root) => [root.source, root.path]));
+  const pluginRecipes = enabledPluginResourceRoots("agents", cwd).sort((left, right) => left.source.localeCompare(right.source)).map((root) => {
+    const skillRoot = skillRoots.get(root.source);
+    return loadRecipesFromDir(
+      {
+        dir: root.path,
+        source: "plugin",
+        rootPath: root.rootPath,
+        cwd,
+        origin: root.source,
+        ...skillRoot === void 0 ? {} : { skillRoot }
+      },
+      diagnostics
+    );
+  });
+  const user = loadRecipesFromDir({ dir: path.join(clioConfigDir(), "agents"), source: "user", cwd }, diagnostics);
+  const project = loadRecipesFromDir(
+    { dir: path.join(cwd, ".clio-coder", "agents"), source: "project", cwd },
+    diagnostics
+  );
+  return mergeRecipes(diagnostics, builtin, ...pluginRecipes, user, project);
+}
+
+export {
+  discoverAgentRecipes
+};
+//# sourceMappingURL=chunk-ZARZ4POR.js.map

package/dist/chunk-ZJPORZTC.js

@@ -0,0 +1,119 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  cwdHash,
+  sessionPaths
+} from "./chunk-EKV4UBCM.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/session/prompt-manifest.ts
+init_esm_shims();
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+var PROMPT_MANIFEST_VERSION = 3;
+var SHA256_HEX = /^[a-f0-9]{64}$/;
+function isCanonicalUtcTimestamp(value) {
+  if (typeof value !== "string") return false;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isSha256(value) {
+  return typeof value === "string" && SHA256_HEX.test(value);
+}
+function isPromptManifestSection(value) {
+  return isRecord(value) && typeof value.id === "string" && isNonNegativeInteger(value.tokenEstimate);
+}
+function isPromptManifestFragment(value) {
+  return isRecord(value) && typeof value.id === "string" && typeof value.relPath === "string" && isSha256(value.contentHash) && typeof value.dynamic === "boolean";
+}
+function isProjectPreloadClass(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const row = value;
+  const integer = (item) => typeof item === "number" && Number.isInteger(item) && item >= 0;
+  const optionalInteger = (item) => item === void 0 || integer(item);
+  const range = (item) => item === null || Array.isArray(item) && item.length === 2 && integer(item[0]) && item[0] >= 1 && integer(item[1]) && item[1] >= item[0];
+  return typeof row.mode === "string" && ["full", "partial", "synopsis", "none"].includes(row.mode) && integer(row.chars) && integer(row.lines) && (row.reason === null || typeof row.reason === "string" && ["size", "lines", "no-clio-md"].includes(row.reason)) && typeof row.nearLimit === "boolean" && typeof row.label === "string" && optionalInteger(row.includedChars) && optionalInteger(row.includedLines) && optionalInteger(row.omittedSupportFragments) && (row.providerSupportsTools === void 0 || row.providerSupportsTools === null || typeof row.providerSupportsTools === "boolean") && (row.sources === void 0 || Array.isArray(row.sources) && row.sources.every((source) => {
+    if (source === null || typeof source !== "object" || Array.isArray(source)) return false;
+    const s = source;
+    return typeof s.path === "string" && typeof s.contentHash === "string" && /^[a-f0-9]{64}$/.test(s.contentHash) && integer(s.availableChars) && integer(s.availableLines) && integer(s.includedChars) && integer(s.includedLines) && s.includedChars <= s.availableChars && s.includedLines <= s.availableLines && range(s.includedRange) && range(s.omittedRange) && (s.omissionReason === null || s.omissionReason === "budget");
+  }));
+}
+function isOptional(value, guard) {
+  return value === void 0 || guard(value);
+}
+function isSessionPromptCompileRecord(value) {
+  if (!isRecord(value)) return false;
+  return isOptional(value.version, isNonNegativeInteger) && isOptional(
+    value.contextWindow,
+    (candidate) => candidate === null ? true : isNonNegativeInteger(candidate)
+  ) && isOptional(
+    value.contextWindowSource,
+    (candidate) => candidate === null ? true : typeof candidate === "string"
+  ) && isCanonicalUtcTimestamp(value.at) && (value.previousHash === null || isSha256(value.previousHash)) && isSha256(value.systemPromptHash) && isNonNegativeInteger(value.tokenEstimate) && (value.thinkingLevel === null || typeof value.thinkingLevel === "string") && (value.projectPreload === null || isProjectPreloadClass(value.projectPreload)) && Array.isArray(value.sections) && value.sections.every(isPromptManifestSection) && Array.isArray(value.fragments) && value.fragments.every(isPromptManifestFragment);
+}
+function getPromptManifestFilePath(meta, stateDir) {
+  const safeMeta = {
+    ...meta,
+    cwdHash: meta.cwdHash || cwdHash(meta.cwd || process.cwd())
+  };
+  if (stateDir !== void 0) {
+    return join(stateDir, "sessions", safeMeta.cwdHash, safeMeta.id, "prompt-manifest.jsonl");
+  }
+  const paths = sessionPaths(safeMeta);
+  return join(dirname(paths.current), "prompt-manifest.jsonl");
+}
+function appendPromptCompileRecord(meta, record) {
+  try {
+    const file = getPromptManifestFilePath(meta);
+    appendFileSync(file, `${JSON.stringify(record)}
+`, "utf8");
+  } catch {
+  }
+}
+function readPromptCompileManifest(meta, stateDir) {
+  const file = getPromptManifestFilePath(meta, stateDir);
+  try {
+    if (!existsSync(file)) return { records: [], errors: [] };
+    const records = [];
+    const errors = [];
+    for (const [index, line] of readFileSync(file, "utf8").split("\n").entries()) {
+      if (line.trim().length === 0) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (isSessionPromptCompileRecord(parsed)) {
+          records.push(parsed);
+        } else {
+          errors.push({ line: index + 1, message: "invalid prompt manifest record" });
+        }
+      } catch {
+        errors.push({ line: index + 1, message: "invalid JSON" });
+      }
+    }
+    return { records, errors };
+  } catch (err) {
+    return {
+      records: [],
+      errors: [{ line: null, message: err instanceof Error ? err.message : String(err) }]
+    };
+  }
+}
+function readPromptCompileRecords(meta) {
+  return readPromptCompileManifest(meta).records;
+}
+
+export {
+  PROMPT_MANIFEST_VERSION,
+  isProjectPreloadClass,
+  getPromptManifestFilePath,
+  appendPromptCompileRecord,
+  readPromptCompileManifest,
+  readPromptCompileRecords
+};
+//# sourceMappingURL=chunk-ZJPORZTC.js.map

package/dist/chunk-ZNUZ3EXD.js

@@ -0,0 +1,243 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  captureProjectSurface,
+  projectSurfaceTrustNotice
+} from "./chunk-X6FLVUM5.js";
+import {
+  SettingsValidationError,
+  applySettingsDelta,
+  settingsPath,
+  updateSavedSettingsDocument,
+  validateSettings
+} from "./chunk-56XP4FJU.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/core/settings-layers.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var STRICT_USER_ISSUES = /* @__PURE__ */ Symbol("strict-user-issues");
+var CREDENTIAL_KEYS = /* @__PURE__ */ new Set(["auth", "apikey", "api_key", "token", "secret", "password"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((entry, index) => deepEquals(entry, b[index]));
+  }
+  if (!isRecord(a) || !isRecord(b)) return false;
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => key in b && deepEquals(a[key], b[key]));
+}
+function readRawLayer(origin, path, issues, capturedText) {
+  if (capturedText === void 0 && !existsSync(path)) return { origin, path, blob: void 0 };
+  let text;
+  try {
+    text = capturedText ?? readFileSync(path, "utf8");
+  } catch (err) {
+    issues.push({
+      origin,
+      path: "(root)",
+      message: `unreadable: ${err instanceof Error ? err.message : String(err)}`,
+      kind: "unreadable"
+    });
+    return { origin, path, blob: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(text);
+  } catch (err) {
+    issues.push({
+      origin,
+      path: "(root)",
+      message: `invalid YAML: ${err instanceof Error ? err.message : String(err)}`,
+      kind: "syntax"
+    });
+    return { origin, path, blob: void 0 };
+  }
+  if (parsed === null || parsed === void 0) return { origin, path, blob: {} };
+  if (!isRecord(parsed)) {
+    issues.push({ origin, path: "(root)", message: "settings file must be a mapping at the root" });
+    return { origin, path, blob: void 0 };
+  }
+  return { origin, path, blob: parsed };
+}
+function stripCredentials(value, origin, path, issues) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => stripCredentials(item, origin, `${path}[${index}]`, issues));
+  }
+  if (!isRecord(value)) return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (CREDENTIAL_KEYS.has(key.toLowerCase())) {
+      issues.push({
+        origin,
+        path: path ? `${path}.${key}` : key,
+        message: "credentials are not allowed in project settings; key ignored"
+      });
+      continue;
+    }
+    out[key] = stripCredentials(child, origin, path ? `${path}.${key}` : key, issues);
+  }
+  return out;
+}
+function mergeLayersWithSources(layers) {
+  const merged = {};
+  const sources = {};
+  for (const layer of layers) {
+    if (layer.blob === void 0) continue;
+    mergeInto(merged, layer.blob, layer.origin, "", sources);
+  }
+  return { merged, sources };
+}
+function mergeInto(target, source, origin, prefix, sources) {
+  for (const [key, value] of Object.entries(source)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (isRecord(value)) {
+      const existing = target[key];
+      const nested = isRecord(existing) ? existing : {};
+      mergeInto(nested, value, origin, path, sources);
+      target[key] = nested;
+      sources[path] = origin;
+    } else {
+      target[key] = Array.isArray(value) ? [...value] : value;
+      sources[path] = origin;
+    }
+  }
+}
+function prepareProjectLayers(cwd, issues) {
+  const projectFile = join(cwd, ".clio-coder", "settings.yaml");
+  const localFile = join(cwd, ".clio-coder", "settings.local.yaml");
+  const snapshot = captureProjectSurface(cwd, "settings");
+  const readProjectLayer = (origin, path, file) => {
+    if (file?.error !== void 0) issues.push({ origin, path, message: file.error, kind: "unreadable" });
+    if (file?.text === null || file === void 0) return { origin, path, blob: void 0 };
+    if (snapshot.verdict !== "trusted") {
+      issues.push({ origin, path, message: projectSurfaceTrustNotice(snapshot, file.path) });
+      return { origin, path, blob: void 0 };
+    }
+    return readRawLayer(origin, path, issues, file.text);
+  };
+  const projectRaw = readProjectLayer("project", projectFile, snapshot.files[0]);
+  const localRaw = readProjectLayer("project.local", localFile, snapshot.files[1]);
+  const project = {
+    ...projectRaw,
+    blob: projectRaw.blob === void 0 ? void 0 : stripCredentials(projectRaw.blob, "project", "", issues)
+  };
+  const local = {
+    ...localRaw,
+    blob: localRaw.blob === void 0 ? void 0 : stripCredentials(localRaw.blob, "project.local", "", issues)
+  };
+  return { projectFile, localFile, projectRaw, localRaw, project, local };
+}
+function validateLayerStack(user, prepared, issues) {
+  const { merged, sources } = mergeLayersWithSources([user, prepared.project, prepared.local]);
+  const validation = validateSettings(merged);
+  for (const issue of validation.issues) {
+    issues.push({ origin: settingsSourceFor(sources, issue.path), path: issue.path, message: issue.message });
+  }
+  return { settings: validation.settings, sources };
+}
+function readLayeredSettings(cwd, options = {}) {
+  const issues = [];
+  const userFile = options.userPath ?? settingsPath();
+  const user = readRawLayer("user", userFile, issues);
+  const prepared = prepareProjectLayers(cwd, issues);
+  const { settings, sources } = validateLayerStack(user, prepared, issues);
+  const strictUserIssues = user.blob === void 0 ? [] : validateSettings(user.blob).issues.map((issue) => ({
+    path: issue.path,
+    message: issue.message,
+    ...issue.kind ? { kind: issue.kind } : {}
+  }));
+  return {
+    settings,
+    sources,
+    issues,
+    layers: [
+      { origin: "built-in", path: "(defaults)", present: true },
+      { origin: "user", path: userFile, present: user.blob !== void 0 },
+      { origin: "project", path: prepared.projectFile, present: prepared.projectRaw.blob !== void 0 },
+      { origin: "project.local", path: prepared.localFile, present: prepared.localRaw.blob !== void 0 }
+    ],
+    [STRICT_USER_ISSUES]: strictUserIssues
+  };
+}
+function readStrictLayeredSettings(cwd, options = {}) {
+  const layered = readLayeredSettings(cwd, options);
+  const reportedUserIssues = layered.issues.filter((issue) => issue.origin === "user").map(({ path, message, kind }) => ({ path, message, ...kind ? { kind } : {} }));
+  const userIssues = [...reportedUserIssues, ...layered[STRICT_USER_ISSUES]].filter(
+    (issue, index, all) => all.findIndex(
+      (candidate) => candidate.path === issue.path && candidate.message === issue.message && candidate.kind === issue.kind
+    ) === index
+  );
+  if (userIssues.length > 0) throw new SettingsValidationError(userIssues);
+  return layered;
+}
+function updateLayeredSettings(cwd, mutate) {
+  let committed = null;
+  updateSavedSettingsDocument((saved) => {
+    const userValidation = validateSettings(saved);
+    if (userValidation.issues.length > 0) throw new SettingsValidationError(userValidation.issues);
+    const issues = [];
+    const prepared = prepareProjectLayers(cwd, issues);
+    const user = {
+      origin: "user",
+      path: settingsPath(),
+      blob: isRecord(saved) ? saved : {}
+    };
+    const before = validateLayerStack(user, prepared, issues).settings;
+    const candidate = structuredClone(before);
+    const next = mutate(candidate) ?? candidate;
+    const candidateValidation = validateSettings(JSON.parse(JSON.stringify(next)));
+    if (candidateValidation.issues.length > 0) throw new SettingsValidationError(candidateValidation.issues);
+    const nextSaved = applySettingsDelta(saved, before, candidateValidation.settings);
+    const finalIssues = [];
+    const final = validateLayerStack(
+      { origin: "user", path: settingsPath(), blob: isRecord(nextSaved) ? nextSaved : {} },
+      prepared,
+      finalIssues
+    ).settings;
+    if (!deepEquals(final, candidateValidation.settings)) {
+      throw new Error("a higher-precedence project setting prevents this settings update");
+    }
+    committed = final;
+    return nextSaved;
+  });
+  if (committed === null) throw new Error("layered settings update did not commit");
+  return committed;
+}
+function settingsSourceFor(sources, keyPath) {
+  let prefix = keyPath;
+  while (prefix.length > 0) {
+    const direct = sources[prefix];
+    if (direct) return direct;
+    const bracket = prefix.lastIndexOf("[");
+    if (bracket >= 0) {
+      const arrayKey = prefix.slice(0, bracket);
+      const hit = sources[arrayKey];
+      if (hit) return hit;
+    }
+    const dot = prefix.lastIndexOf(".");
+    if (dot < 0) break;
+    prefix = prefix.slice(0, dot);
+  }
+  return "built-in";
+}
+
+export {
+  readLayeredSettings,
+  readStrictLayeredSettings,
+  updateLayeredSettings,
+  settingsSourceFor
+};
+//# sourceMappingURL=chunk-ZNUZ3EXD.js.map

package/dist/chunk-ZPST2KQO.js

@@ -0,0 +1,49 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/core/package-root.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+var cached = null;
+var cachedClioVersion = null;
+function resolvePackageRoot(metaUrl = import.meta.url) {
+  if (cached) return cached;
+  const override = process.env.CLIO_CODER_PACKAGE_ROOT?.trim();
+  if (override) {
+    cached = resolve(override);
+    return cached;
+  }
+  let dir = resolve(dirname(fileURLToPath(metaUrl)));
+  while (true) {
+    if (existsSync(join(dir, "package.json"))) {
+      cached = dir;
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(`Could not find package.json above ${dir}`);
+    }
+    dir = parent;
+  }
+}
+function readPackageJson() {
+  const root = resolvePackageRoot();
+  const raw = readFileSync(join(root, "package.json"), "utf8");
+  return JSON.parse(raw);
+}
+function readClioVersion() {
+  if (cachedClioVersion) return cachedClioVersion;
+  const pkg = readPackageJson();
+  cachedClioVersion = pkg.version ?? "0.0.0";
+  return cachedClioVersion;
+}
+
+export {
+  resolvePackageRoot,
+  readClioVersion
+};
+//# sourceMappingURL=chunk-ZPST2KQO.js.map