@event4u/agent-config 9.10.0 → 9.12.0

package/dist/cli-delegate/chunk-EJYIGZ3T.js

@@ -0,0 +1,125 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  LEGACY_ALL,
+  ruleFileArrives
+} from "./chunk-TJIAM5FW.js";
+
+// src/install/wizard-plan.ts
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+var USER_SCOPE_PATHS = {
+  "claude-code": "~/.claude/",
+  "claude-desktop": "~/Library/Application Support/Claude/",
+  cursor: "~/.cursor/",
+  windsurf: "~/.codeium/windsurf/",
+  cline: "~/Documents/Cline/Rules/",
+  "gemini-cli": "~/.gemini/",
+  copilot: "~/.copilot/",
+  augment: "~/.augment/",
+  aider: "~/.aider.conf.yml",
+  codex: "~/.codex/",
+  roocode: "~/.roo/",
+  continue: "~/.continue/",
+  kilocode: "~/.kilocode/",
+  zed: "~/.config/zed/",
+  jetbrains: "~/.config/JetBrains/",
+  kiro: "~/.kiro/",
+  qoder: "~/.qoder/",
+  opencode: "~/.opencode/",
+  trae: "~/.trae/",
+  antigravity: "~/.agents/",
+  codebuddy: "~/.codebuddy/",
+  droid: "~/.factory/",
+  warp: "~/.warp/"
+};
+var CLAUDE_SKILL_BUNDLE = [
+  ["dist/agent-src/rules", "rules"],
+  ["dist/agent-src/skills", "skills"],
+  // Commands ship to ~/.claude/commands/ — native Claude Code slash-
+  // command surface. Verified empirically 2026-05-28: rich frontmatter
+  // (disable-model-invocation, custom fields) tolerated; nested
+  // subdirs route as `/<cluster>:<sub>`. Council session 2026-05-28
+  // converged on Option B (native slash-only) — see
+  // agents/runtime/council/responses/claude-code-distribution.json
+  // and scripts/install.py:_CLAUDE_SKILL_BUNDLE for the Python mirror.
+  ["dist/agent-src/commands", "commands"],
+  ["dist/agent-src/personas", "personas"]
+];
+var RULE_SOURCE_REL = "dist/agent-src/rules";
+var GLOBAL_DEPLOY_SOURCES = {
+  "claude-code": CLAUDE_SKILL_BUNDLE,
+  augment: [
+    ["dist/agent-src/rules", "rules"],
+    ["dist/agent-src/skills", "skills"],
+    ["dist/agent-src/commands", "commands"],
+    ["dist/agent-src/contexts", "contexts"],
+    ["dist/agent-src/personas", "personas"],
+    ["dist/agent-src/templates", "templates"]
+  ],
+  cursor: [
+    ["dist/agent-src/rules", "rules"],
+    ["dist/agent-src/commands", "commands"],
+    ["dist/agent-src/personas", "personas"]
+  ],
+  windsurf: [
+    ["dist/agent-src/rules", "rules"]
+  ],
+  cline: [
+    ["dist/agent-src/rules", ""]
+  ],
+  "gemini-cli": CLAUDE_SKILL_BUNDLE,
+  codex: CLAUDE_SKILL_BUNDLE,
+  continue: CLAUDE_SKILL_BUNDLE,
+  roocode: CLAUDE_SKILL_BUNDLE,
+  kilocode: CLAUDE_SKILL_BUNDLE,
+  qoder: CLAUDE_SKILL_BUNDLE,
+  opencode: CLAUDE_SKILL_BUNDLE,
+  trae: CLAUDE_SKILL_BUNDLE,
+  antigravity: CLAUDE_SKILL_BUNDLE,
+  codebuddy: CLAUDE_SKILL_BUNDLE,
+  droid: CLAUDE_SKILL_BUNDLE,
+  warp: CLAUDE_SKILL_BUNDLE,
+  kiro: [
+    ["dist/agent-src/rules", "rules"],
+    ["dist/agent-src/skills", "steering"],
+    ["dist/agent-src/personas", "personas"]
+  ]
+};
+function expandAnchor(anchor, home) {
+  const h = home ?? homedir();
+  if (anchor === "~") return h;
+  if (anchor.startsWith("~/")) return join(h, anchor.slice(2));
+  if (isAbsolute(anchor)) return anchor;
+  return resolve(anchor);
+}
+function expandWizardSources(inputs) {
+  const { toolIds, packageRoot, home } = inputs;
+  const scope = inputs.ruleScope ?? LEGACY_ALL;
+  const ruleFilter = (srcFile) => ruleFileArrives(srcFile, scope);
+  const out = [];
+  for (const toolId of toolIds) {
+    const deploy = GLOBAL_DEPLOY_SOURCES[toolId];
+    const anchor = USER_SCOPE_PATHS[toolId];
+    if (!deploy || !anchor) continue;
+    const destRoot = expandAnchor(anchor, home);
+    for (const [srcRel, destSub] of deploy) {
+      const srcDir = join(packageRoot, srcRel);
+      const destDir = destSub.length === 0 ? destRoot : join(destRoot, destSub);
+      const isRuleSource = srcRel === RULE_SOURCE_REL;
+      out.push({
+        toolId,
+        srcDir,
+        destDir,
+        kind: "deployed",
+        ...isRuleSource ? { fileFilter: ruleFilter } : {}
+      });
+    }
+  }
+  return out;
+}
+
+export {
+  RULE_SOURCE_REL,
+  GLOBAL_DEPLOY_SOURCES,
+  expandWizardSources
+};

package/dist/cli-delegate/chunk-FTAISGDQ.js

@@ -0,0 +1,117 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_lib/claude_plugin.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import process from "node:process";
+var CLAUDE_PLUGIN_ID = "agent-config";
+var CLAUDE_MARKETPLACE_NAME = "event4u-agent-config";
+var CLAUDE_MARKETPLACE_REPO = "event4u-app/agent-config";
+var CLAUDE_PLUGIN_INSTALL_HINT = [
+  `claude plugin marketplace add ${CLAUDE_MARKETPLACE_REPO}`,
+  `claude plugin install ${CLAUDE_PLUGIN_ID}@${CLAUDE_MARKETPLACE_NAME}`
+];
+var CODEX_PLUGIN_ID = "codex";
+var CODEX_MARKETPLACE_NAME = "openai-codex";
+var CODEX_MARKETPLACE_REPO = "openai/codex-plugin-cc";
+var CODEX_PLUGIN_INSTALL_HINT = [
+  `claude plugin marketplace add ${CODEX_MARKETPLACE_REPO}`,
+  `claude plugin install ${CODEX_PLUGIN_ID}@${CODEX_MARKETPLACE_NAME}`
+];
+function claude_config_dir() {
+  const env = (process.env["CLAUDE_CONFIG_DIR"] ?? "").trim();
+  return env !== "" ? env : path.join(os.homedir(), ".claude");
+}
+function _plugin_id_recorded(plugin_id) {
+  const p = path.join(claude_config_dir(), "plugins", "installed_plugins.json");
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch {
+    return false;
+  }
+  if (data === null || typeof data !== "object") return false;
+  const plugins = data.plugins;
+  if (plugins === null || plugins === void 0 || typeof plugins !== "object") return false;
+  return Object.keys(plugins).some(
+    (k) => k.startsWith(`${plugin_id}@`)
+  );
+}
+function claude_plugin_installed() {
+  return _plugin_id_recorded(CLAUDE_PLUGIN_ID);
+}
+function _plugin_marketplaces(plugin_id) {
+  const p = path.join(claude_config_dir(), "plugins", "installed_plugins.json");
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch {
+    return [];
+  }
+  if (data === null || typeof data !== "object") return [];
+  const plugins = data.plugins;
+  if (plugins === null || plugins === void 0 || typeof plugins !== "object") return [];
+  const prefix = `${plugin_id}@`;
+  return Object.keys(plugins).filter((k) => k.startsWith(prefix)).map((k) => k.slice(prefix.length));
+}
+function _marketplace_source_repo(marketplace) {
+  const p = path.join(claude_config_dir(), "plugins", "known_marketplaces.json");
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (data === null || typeof data !== "object") return null;
+  const entry = data[marketplace];
+  if (entry === null || entry === void 0 || typeof entry !== "object") return null;
+  const source = entry.source;
+  if (source === null || source === void 0 || typeof source !== "object") return null;
+  const repo = source.repo;
+  return typeof repo === "string" && repo.trim() !== "" ? repo.trim() : null;
+}
+function codex_plugin_identity() {
+  const marketplaces = _plugin_marketplaces(CODEX_PLUGIN_ID);
+  if (marketplaces.length === 0) {
+    return { installed: false, identity_verified: false };
+  }
+  const want = CODEX_MARKETPLACE_REPO.toLowerCase();
+  const identity_verified = marketplaces.some(
+    (m) => (_marketplace_source_repo(m) ?? "").toLowerCase() === want
+  );
+  return { installed: true, identity_verified };
+}
+function claude_plugin_snapshot_version() {
+  const p = path.join(
+    claude_config_dir(),
+    "plugins",
+    "marketplaces",
+    CLAUDE_MARKETPLACE_NAME,
+    ".claude-plugin",
+    "marketplace.json"
+  );
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(p, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (data === null || typeof data !== "object") return null;
+  const metadata = data.metadata;
+  if (metadata === null || metadata === void 0 || typeof metadata !== "object") return null;
+  const v = metadata.version;
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : null;
+}
+
+export {
+  CLAUDE_PLUGIN_ID,
+  CLAUDE_MARKETPLACE_NAME,
+  CODEX_PLUGIN_ID,
+  CODEX_MARKETPLACE_NAME,
+  CODEX_PLUGIN_INSTALL_HINT,
+  claude_config_dir,
+  claude_plugin_installed,
+  codex_plugin_identity,
+  claude_plugin_snapshot_version
+};

package/dist/cli-delegate/chunk-GME3Q44L.js

@@ -0,0 +1,82 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+
+// src/scripts/_cli/explain_last/state_loader.ts
+import * as fs from "node:fs";
+var EXPECTED_VERSION = 1;
+var StateLoadError = class extends Error {
+  exitCode;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "StateLoadError";
+    this.exitCode = options.exitCode ?? 2;
+  }
+};
+function _pyRepr(value) {
+  if (value === null || value === void 0) {
+    return "None";
+  }
+  if (typeof value === "boolean") {
+    return value ? "True" : "False";
+  }
+  if (typeof value === "string") {
+    if (value.includes("'") && !value.includes('"')) {
+      return `"${value}"`;
+    }
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  }
+  return String(value);
+}
+function load_state(state_file) {
+  if (!fs.existsSync(state_file)) {
+    throw new StateLoadError(`state file not found: ${state_file}`, {
+      exitCode: 1
+    });
+  }
+  let text;
+  try {
+    text = fs.readFileSync(state_file, "utf-8");
+  } catch (exc) {
+    throw new StateLoadError(
+      `cannot read state file ${state_file}: ${_osErr(exc)}`
+    );
+  }
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch (exc) {
+    throw new StateLoadError(
+      `state file ${state_file} is not valid JSON: ${_jsonErr(exc, text)}`
+    );
+  }
+  if (typeof payload !== "object" || payload === null || Array.isArray(payload)) {
+    throw new StateLoadError(
+      `state file ${state_file} must contain a JSON object`
+    );
+  }
+  const version = payload.version;
+  if (version !== EXPECTED_VERSION) {
+    throw new StateLoadError(
+      `trace format upgraded; rerun the upstream command on this branch to regenerate (found version=${_pyRepr(version === void 0 ? null : version)}, expected ${EXPECTED_VERSION})`,
+      { exitCode: 0 }
+      // informational, not a failure (council fix).
+    );
+  }
+  return payload;
+}
+function _osErr(exc) {
+  if (exc instanceof Error) {
+    return exc.message;
+  }
+  return String(exc);
+}
+function _jsonErr(exc, _text) {
+  if (exc instanceof Error) {
+    return exc.message;
+  }
+  return String(exc);
+}
+
+export {
+  StateLoadError,
+  load_state
+};

package/dist/cli-delegate/chunk-GRRPEPRN.js

@@ -0,0 +1,336 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  resolve_with_fallback,
+  write_target
+} from "./chunk-NDJLNC6Q.js";
+
+// src/scripts/_lib/installed_lock.ts
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/scripts/_lib/install_layout.ts
+var PRE_FREEZE_LAYOUT_VERSION = 0;
+var INSTALL_LAYOUT_VERSION = 1;
+function _pyInt(value) {
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      return null;
+    }
+    return Math.trunc(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!/^[+-]?\d+(?:_\d+)*$/.test(trimmed)) {
+      return null;
+    }
+    return Number.parseInt(trimmed.replace(/_/g, ""), 10);
+  }
+  return null;
+}
+function coerce_layout_version(value) {
+  if (value === null || value === void 0) {
+    return PRE_FREEZE_LAYOUT_VERSION;
+  }
+  const parsed = _pyInt(value);
+  if (parsed === null) {
+    return PRE_FREEZE_LAYOUT_VERSION;
+  }
+  return parsed;
+}
+function needs_migration(recorded) {
+  return coerce_layout_version(recorded) < INSTALL_LAYOUT_VERSION;
+}
+
+// src/scripts/_lib/installed_lock.ts
+var LOCKFILE_ENV = "AGENT_CONFIG_INSTALLED_LOCK";
+var SCHEMA_VERSION = 1;
+function _default_lockfile() {
+  return write_target("installed.lock");
+}
+var DEFAULT_LOCKFILE = _default_lockfile();
+var _VERSION_RE = /^\s*agent_config_version\s*:\s*"?([^"\s]+)"?\s*$/;
+var _SCHEMA_RE = /^\s*schema_version\s*:\s*(\d+)\s*$/;
+var _LAYOUT_RE = /^\s*install_layout_version\s*:\s*(\d+)\s*$/;
+var _INSTALLED_AT_RE = /^\s*installed_at\s*:\s*"?([^"\s]+)"?\s*$/;
+var _TOOL_RE = /^\s*-\s*([A-Za-z0-9_\-.]+)\s*$/;
+function expanduser(p) {
+  if (p === "~") {
+    return os.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function lockfile_path(env) {
+  const env_map = env ?? process.env;
+  const override = env_map[LOCKFILE_ENV];
+  if (override) {
+    return expanduser(override);
+  }
+  const resolved = resolve_with_fallback("installed.lock", { env: env ?? null });
+  if (resolved !== null) {
+    return resolved;
+  }
+  return write_target("installed.lock", { env: env ?? null });
+}
+function lockfile_write_path(env) {
+  const env_map = env ?? process.env;
+  const override = env_map[LOCKFILE_ENV];
+  if (override) {
+    return expanduser(override);
+  }
+  return write_target("installed.lock", { env: env ?? null });
+}
+function read_lockfile(path2) {
+  const target = path2 ?? lockfile_path();
+  let text;
+  try {
+    text = fs.readFileSync(target, { encoding: "utf-8" });
+  } catch {
+    return null;
+  }
+  const data = { tools: [] };
+  let in_tools = false;
+  for (const raw_line of splitlines(text)) {
+    const schema_m = _SCHEMA_RE.exec(raw_line);
+    if (schema_m) {
+      data.schema_version = Number.parseInt(schema_m[1], 10);
+      in_tools = false;
+      continue;
+    }
+    const layout_m = _LAYOUT_RE.exec(raw_line);
+    if (layout_m) {
+      data.install_layout_version = Number.parseInt(layout_m[1], 10);
+      in_tools = false;
+      continue;
+    }
+    const version_m = _VERSION_RE.exec(raw_line);
+    if (version_m) {
+      data.agent_config_version = version_m[1];
+      in_tools = false;
+      continue;
+    }
+    const installed_m = _INSTALLED_AT_RE.exec(raw_line);
+    if (installed_m) {
+      data.installed_at = installed_m[1];
+      in_tools = false;
+      continue;
+    }
+    if (raw_line.trim().startsWith("tools:")) {
+      in_tools = true;
+      continue;
+    }
+    if (in_tools) {
+      const m = _TOOL_RE.exec(raw_line);
+      if (m) {
+        data.tools.push(m[1]);
+      } else if (raw_line.trim() && !(raw_line.startsWith(" ") || raw_line.startsWith("	") || raw_line.startsWith("-"))) {
+        in_tools = false;
+      }
+    }
+  }
+  return data;
+}
+function splitlines(text) {
+  const parts = text.split("\n");
+  if (parts.length > 0 && parts[parts.length - 1] === "") {
+    parts.pop();
+  }
+  return parts;
+}
+function _render(version, tools, installed_at) {
+  const lines = [
+    `schema_version: ${SCHEMA_VERSION}`,
+    `install_layout_version: ${INSTALL_LAYOUT_VERSION}`,
+    `agent_config_version: "${version}"`,
+    `installed_at: "${installed_at}"`,
+    "tools:"
+  ];
+  for (const tool of tools) {
+    lines.push(`  - ${tool}`);
+  }
+  return lines.join("\n") + "\n";
+}
+function write_lockfile(version, tools, options = {}) {
+  const target = options.path ?? lockfile_path();
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const stamp = strftime_iso_z(options.now ?? /* @__PURE__ */ new Date());
+  const rendered = _render(version, sorted_unique(tools), stamp);
+  const parent = path.dirname(target);
+  const { fd, tmp_name } = mkstemp(parent, ".installed.lock.");
+  try {
+    fs.writeFileSync(fd, rendered, { encoding: "utf-8" });
+    fs.closeSync(fd);
+    fs.renameSync(tmp_name, target);
+  } catch (err) {
+    try {
+      fs.closeSync(fd);
+    } catch {
+    }
+    try {
+      fs.unlinkSync(tmp_name);
+    } catch {
+    }
+    throw err;
+  }
+  return target;
+}
+function _parse_installed_at(stamp) {
+  if (!stamp) {
+    return null;
+  }
+  const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/.exec(stamp);
+  if (!m) {
+    return null;
+  }
+  const [, y, mo, d, h, mi, s] = m;
+  const ms = Date.UTC(
+    Number.parseInt(y, 10),
+    Number.parseInt(mo, 10) - 1,
+    Number.parseInt(d, 10),
+    Number.parseInt(h, 10),
+    Number.parseInt(mi, 10),
+    Number.parseInt(s, 10)
+  );
+  const parsed = new Date(ms);
+  if (parsed.getUTCFullYear() !== Number.parseInt(y, 10) || parsed.getUTCMonth() !== Number.parseInt(mo, 10) - 1 || parsed.getUTCDate() !== Number.parseInt(d, 10) || parsed.getUTCHours() !== Number.parseInt(h, 10) || parsed.getUTCMinutes() !== Number.parseInt(mi, 10) || parsed.getUTCSeconds() !== Number.parseInt(s, 10)) {
+    return null;
+  }
+  return parsed;
+}
+function migrate_layout(options = {}) {
+  const target = options.path ?? lockfile_write_path();
+  const existing = read_lockfile(target);
+  if (existing === null) {
+    return null;
+  }
+  const from_v = coerce_layout_version(existing.install_layout_version);
+  if (!needs_migration(existing.install_layout_version)) {
+    return { from: from_v, to: from_v, changed: [] };
+  }
+  const version = existing.agent_config_version || current_package_version();
+  const tools = [...existing.tools ?? []];
+  const when = options.now ?? _parse_installed_at(existing.installed_at);
+  write_lockfile(version, tools, { path: target, now: when });
+  return {
+    from: from_v,
+    to: INSTALL_LAYOUT_VERSION,
+    changed: [`install_layout_version ${from_v} \u2192 ${INSTALL_LAYOUT_VERSION}`]
+  };
+}
+function sorted_unique(tools) {
+  return [...new Set(tools)].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function strftime_iso_z(now) {
+  return now.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function mkstemp(dir, prefix) {
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    const tmp_name = path.join(dir, `${prefix}${randomBytes(6).toString("hex")}`);
+    try {
+      const fd = fs.openSync(tmp_name, "wx", 384);
+      return { fd, tmp_name };
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error("mkstemp: could not create a unique temp file");
+}
+function check_version(installed_version, options = {}) {
+  const existing = read_lockfile(options.path ?? null);
+  if (existing === null) {
+    return [true, null];
+  }
+  const recorded = existing.agent_config_version;
+  if (!recorded) {
+    return [true, null];
+  }
+  return [recorded === installed_version, recorded];
+}
+var _SEMVER_RE = /^\s*v?(\d+)\.(\d+)\.(\d+)/;
+function _parse_semver(version) {
+  const match = _SEMVER_RE.exec(version);
+  if (!match) {
+    return null;
+  }
+  return [Number.parseInt(match[1], 10), Number.parseInt(match[2], 10), Number.parseInt(match[3], 10)];
+}
+function classify_mismatch(installed_version, recorded) {
+  if (recorded === null) {
+    return "none";
+  }
+  if (recorded === installed_version) {
+    return "match";
+  }
+  const rec = _parse_semver(recorded);
+  const inst = _parse_semver(installed_version);
+  if (rec === null || inst === null) {
+    return "unparseable";
+  }
+  if (tuple_lt(rec, inst)) {
+    return "upgrade";
+  }
+  return "downgrade";
+}
+function tuple_lt(a, b) {
+  for (let i = 0; i < a.length; i += 1) {
+    const av = a[i];
+    const bv = b[i];
+    if (av < bv) return true;
+    if (av > bv) return false;
+  }
+  return false;
+}
+function _read_package_version(dir) {
+  try {
+    const data = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), { encoding: "utf-8" }));
+    const version = data.version;
+    if (typeof version === "string" && version.trim()) {
+      return version.trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function _find_package_version_upward(start_dir) {
+  let dir = start_dir;
+  for (; ; ) {
+    const found = _read_package_version(dir);
+    if (found !== null) {
+      return found;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
+  }
+}
+function current_package_version(repo_root) {
+  if (repo_root != null) {
+    return _read_package_version(repo_root) ?? "0.0.0";
+  }
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  return _find_package_version_upward(here) ?? "0.0.0";
+}
+
+export {
+  lockfile_path,
+  lockfile_write_path,
+  read_lockfile,
+  write_lockfile,
+  migrate_layout,
+  check_version,
+  classify_mismatch,
+  current_package_version
+};