@quatronic/sdk 0.6.1-rc.4 → 0.7.0-rc.6

package/dist/cli/skills-postinstall.js

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+
+// src/cli/skills-postinstall.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync as realpathSync2 } from "fs";
+import { dirname as dirname2, join as join2, resolve as resolve2, sep } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/cli/skills-core.ts
+import { createHash } from "crypto";
+var MANIFEST_PATH = "qore/manifest.json";
+var INDEX_PATH = "qore/skills.md";
+var README_PATH = "qore/README.md";
+var EXTENSIONS_DIR = "qore/extensions";
+var CLAUDE_MD_IMPORT = "@.claude/qore/skills.md";
+var RUNTIMES = ["next", "node"];
+var AUTHS = ["none", "keycloak", "betterauth"];
+function parseFeatures(raw) {
+  const o = raw ?? {};
+  if (!RUNTIMES.includes(o.runtime)) throw new Error(`features.runtime must be one of ${RUNTIMES.join("|")}`);
+  if (!AUTHS.includes(o.auth)) throw new Error(`features.auth must be one of ${AUTHS.join("|")}`);
+  if (typeof o.db !== "boolean") throw new Error("features.db must be a boolean");
+  return { runtime: o.runtime, auth: o.auth, db: o.db };
+}
+function inferFeatures(pkg, exists) {
+  const deps = { ...pkg.devDependencies, ...pkg.dependencies };
+  const runtime = "next" in deps ? "next" : "node";
+  const auth = "better-auth" in deps ? "betterauth" : exists("src/lib/permissions.ts") ? "keycloak" : "none";
+  const db = "drizzle-orm" in deps || Boolean(pkg.scripts?.["db:up"]) || exists("docker-compose.yml");
+  return { runtime, auth, db };
+}
+function evalCondition(expr, f) {
+  const e = expr.trim();
+  if (e.startsWith("!")) return !evalCondition(e.slice(1), f);
+  const [key, value] = e.split("=", 2);
+  const options = value === void 0 ? void 0 : value.split("|");
+  switch (key) {
+    case "runtime":
+      if (!options) throw new Error(`condition "${e}" needs a value`);
+      return options.includes(f.runtime);
+    case "auth":
+      return options ? options.includes(f.auth) : f.auth !== "none";
+    case "db":
+      if (options) throw new Error(`condition "${e}" takes no value`);
+      return f.db;
+    default:
+      throw new Error(`unknown condition "${e}"`);
+  }
+}
+var TAG = /\{\{(#if [^}]+|else|\/if)\}\}/g;
+var LINE_START_TAG = /^[ \t]+(?=\{\{(?:#if [^}]+|else|\/if)\}\})/gm;
+function renderTemplate(src, f) {
+  const text = src.replace(/\r\n/g, "\n").replace(LINE_START_TAG, "");
+  const root = [];
+  const stack = [];
+  const push = (n) => {
+    const top = stack.at(-1);
+    if (!top) root.push(n);
+    else (top.inElse ? top.node.else : top.node.then).push(n);
+  };
+  let last = 0;
+  for (const m of text.matchAll(TAG)) {
+    push(text.slice(last, m.index));
+    last = m.index + m[0].length;
+    if (text[last] === "\n") last += 1;
+    const tag = m[1];
+    if (tag.startsWith("#if ")) {
+      const cond = tag.slice(4).trim();
+      evalCondition(cond, { runtime: "next", auth: "none", db: false });
+      const node = { cond, then: [], else: [] };
+      push(node);
+      stack.push({ node, inElse: false });
+    } else if (tag === "else") {
+      const top = stack.at(-1);
+      if (!top || top.inElse) throw new Error("{{else}} without a matching {{#if}}");
+      top.inElse = true;
+    } else {
+      if (!stack.pop()) throw new Error("{{/if}} without a matching {{#if}}");
+    }
+  }
+  if (stack.length) throw new Error(`unclosed {{#if ${stack.at(-1).node.cond}}}`);
+  push(text.slice(last));
+  const emit = (nodes) => nodes.map((n) => typeof n === "string" ? n : emit(evalCondition(n.cond, f) ? n.then : n.else)).join("");
+  return emit(root);
+}
+var VARIANT = /^(.*)\.(next|node)(\.[^./]+)$/;
+function skillApplies(entry, f) {
+  return (entry.requires ?? []).every((c) => evalCondition(c, f));
+}
+function renderSkills(catalog, sources, f) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of catalog.skills) {
+    if (!skillApplies(entry, f)) continue;
+    const prefix = `${entry.name}/`;
+    for (const [key, src] of [...sources].sort(([a], [b]) => a.localeCompare(b))) {
+      if (!key.startsWith(prefix)) continue;
+      let rel = key.slice(prefix.length);
+      const v = VARIANT.exec(rel);
+      if (v) {
+        if (v[2] !== f.runtime) continue;
+        rel = `${v[1]}${v[3]}`;
+      }
+      out.set(`skills/${entry.name}/${rel}`, renderTemplate(src, f));
+    }
+  }
+  return out;
+}
+function frontmatterField(text, field) {
+  const fm = /^---\n([\s\S]*?)\n---\n/.exec(text);
+  if (!fm) return void 0;
+  const line = fm[1].split("\n").find((l) => l.startsWith(`${field}:`));
+  return line?.slice(field.length + 1).trim();
+}
+function extensionFooter(entry) {
+  const path = `.claude/${EXTENSIONS_DIR}/${entry.name}.md`;
+  const rule = entry.kind === "contract" ? "It may add steps and conventions to this skill but cannot relax it: the portal reads what this skill produces." : "Where it conflicts with this skill, it wins.";
+  return `
+---
+
+*Managed by \`@quatronic/sdk\` \u2014 do not edit this file; the next SDK update overwrites it.*
+If \`${path}\` exists, read it before you start: it is this app team's extension of the skill. ${rule}
+`;
+}
+function renderIndex(catalog, skills) {
+  const rows = catalog.skills.filter((e) => skills.has(`skills/${e.name}/SKILL.md`)).map((e) => {
+    const desc = frontmatterField(skills.get(`skills/${e.name}/SKILL.md`), "description") ?? "";
+    return `| \`/${e.name}\` | ${e.kind} | ${desc.replace(/\|/g, "\\|")} |`;
+  });
+  return [
+    "# Qore skills",
+    "",
+    "Managed by `@quatronic/sdk`; see `.claude/qore/README.md` for how to disable, extend or detach one.",
+    "",
+    "**Never edit `.claude/skills/qore-*` or anything under `.claude/qore/` except `extensions/`** \u2014 the next SDK update overwrites it. To add, change, extend or turn off a skill, use `/qore-author-skill`.",
+    "",
+    "| Skill | Kind | When to use |",
+    "|---|---|---|",
+    ...rows,
+    ""
+  ].join("\n");
+}
+var README = `# Managed Qore skills
+
+The skills under \`.claude/skills/qore-*\` come from \`@quatronic/sdk\` and are
+updated with it: an SDK upgrade PR re-syncs them (\`pnpm exec qore-skills sync\`).
+\`manifest.json\` here records the SDK version, this app's features and a hash
+of every managed file.
+
+## What you can do
+
+| You want to\u2026 | Do this |
+|---|---|
+| Turn a skill off | \`"skillOverrides": { "qore-add-page": "off" }\` in \`.claude/settings.json\` |
+| Add your own conventions | Write \`.claude/qore/extensions/<skill>.md\`; the skill tells Claude to read it |
+| Replace a skill | Turn ours off and write your own skill under a name without the \`qore-\` prefix |
+| Own a copy | Add the skill's name to \`detached\` in \`manifest.json\`; sync stops touching it |
+
+\`/qore-author-skill\` walks through each of these.
+
+Editing a managed file in place does not stick: the next sync overwrites it and
+lists it in the PR, so the change is still in that PR's diff to move into an
+extension file.
+
+## Contract skills
+
+\`qore-add-integration\`, \`qore-add-connection\`, \`qore-use-permissions\`,
+\`qore-observability\` and \`qore-use-database\` produce code the portal reads:
+the Integrations tab, connections, roles, Monitoring, the local database. An
+extension may add to them but not relax them, and turning one off does not turn
+off the SDK's lint rules that check the same things.
+
+The \`qore-\` prefix is reserved for managed skills. Sync never touches a skill
+it does not ship, so your own skills are safe under any other name.
+`;
+function buildTree(catalog, sources, f) {
+  const skills = renderSkills(catalog, sources, f);
+  for (const entry of catalog.skills) {
+    const key = `skills/${entry.name}/SKILL.md`;
+    const body = skills.get(key);
+    if (body !== void 0) skills.set(key, body.replace(/\n*$/, "\n") + extensionFooter(entry));
+  }
+  skills.set(INDEX_PATH, renderIndex(catalog, skills));
+  skills.set(README_PATH, README);
+  return skills;
+}
+function normalise(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function hashContent(text) {
+  return `sha256:${createHash("sha256").update(normalise(text), "utf8").digest("hex")}`;
+}
+function parseManifest(text) {
+  const raw = JSON.parse(text);
+  if (raw.schemaVersion !== 1) throw new Error(`unsupported manifest schemaVersion ${String(raw.schemaVersion)}`);
+  return {
+    schemaVersion: 1,
+    sdkVersion: String(raw.sdkVersion ?? ""),
+    features: parseFeatures(raw.features),
+    ...raw.featureOverride === void 0 ? {} : { featureOverride: parseFeatures(raw.featureOverride) },
+    detached: Array.isArray(raw.detached) ? raw.detached.map(String) : [],
+    files: raw.files ?? {}
+  };
+}
+function renderManifest(m) {
+  const files = Object.fromEntries(Object.entries(m.files).sort(([a], [b]) => a.localeCompare(b)));
+  return `${JSON.stringify({ ...m, files }, null, 2)}
+`;
+}
+var skillOf = (rel) => /^skills\/([^/]+)\//.exec(rel)?.[1];
+function planSync(s) {
+  const detached = new Set(s.manifest?.detached ?? []);
+  const managed = (rel) => {
+    const skill = skillOf(rel);
+    return !(skill && detached.has(skill));
+  };
+  const tree = new Map([...s.tree].filter(([rel]) => managed(rel)));
+  const known = s.manifest?.files ?? {};
+  const writes = /* @__PURE__ */ new Map();
+  const edited = [];
+  const adopted = [];
+  for (const [rel, content] of tree) {
+    const disk = s.read(rel);
+    if (disk !== void 0 && normalise(disk) === content) continue;
+    if (disk !== void 0) {
+      if (!(rel in known)) adopted.push(rel);
+      else if (hashContent(disk) !== known[rel]) edited.push(rel);
+    }
+    writes.set(rel, content);
+  }
+  const deletes = [];
+  for (const rel of Object.keys(known)) {
+    if (tree.has(rel) || !managed(rel) || s.read(rel) === void 0) continue;
+    deletes.push(rel);
+    if (hashContent(s.read(rel)) !== known[rel]) edited.push(rel);
+  }
+  const legacyRemoved = [];
+  for (const entry of s.catalog.skills) {
+    if (detached.has(entry.name)) continue;
+    for (const legacy of entry.legacyNames ?? []) {
+      const files = s.listDir(`skills/${legacy}`);
+      if (!files.length) continue;
+      legacyRemoved.push(`skills/${legacy}`);
+      deletes.push(...files);
+    }
+  }
+  let claudeMd = s.claudeMd;
+  const claudeMdRenamed = [];
+  let claudeMdImportAdded = false;
+  if (claudeMd !== void 0) {
+    for (const entry of s.catalog.skills) {
+      for (const legacy of entry.legacyNames ?? []) {
+        const exact = new RegExp(`(?<![a-z0-9-])${legacy}(?![a-z0-9-])`, "g");
+        if (!exact.test(claudeMd)) continue;
+        claudeMd = claudeMd.replace(exact, entry.name);
+        claudeMdRenamed.push([legacy, entry.name]);
+      }
+    }
+    if (!claudeMd.split(/\r?\n/).some((l) => l.trim() === CLAUDE_MD_IMPORT)) {
+      claudeMd = `${claudeMd.replace(/\s*$/, "")}
+
+${CLAUDE_MD_IMPORT}
+`;
+      claudeMdImportAdded = true;
+    }
+  }
+  const manifest = {
+    schemaVersion: 1,
+    sdkVersion: s.sdkVersion,
+    features: s.features,
+    ...s.featureOverride ? { featureOverride: s.featureOverride } : {},
+    detached: [...detached].sort(),
+    files: Object.fromEntries([...tree].map(([rel, c]) => [rel, hashContent(c)]))
+  };
+  const manifestText = renderManifest(manifest);
+  if (s.read(MANIFEST_PATH) === void 0 || normalise(s.read(MANIFEST_PATH)) !== manifestText) {
+    writes.set(MANIFEST_PATH, manifestText);
+  }
+  return {
+    writes,
+    deletes: deletes.sort(),
+    edited: edited.sort(),
+    adopted: adopted.sort(),
+    legacyRemoved: legacyRemoved.sort(),
+    manifest,
+    claudeMd: claudeMd === s.claudeMd ? void 0 : claudeMd,
+    claudeMdRenamed: claudeMdRenamed.sort(([a], [b]) => a.localeCompare(b)),
+    claudeMdImportAdded
+  };
+}
+function planChanges(p) {
+  return p.writes.size > 0 || p.deletes.length > 0 || p.claudeMd !== void 0;
+}
+function renderReport(p, opts) {
+  const f = p.manifest.features;
+  const lines = [
+    "### Qore skills",
+    "",
+    `Synced the managed skills for \`@quatronic/sdk@${p.manifest.sdkVersion}\` (runtime \`${f.runtime}\`, auth \`${f.auth}\`, database \`${f.db ? "yes" : "no"}\`${opts.inferred ? ", inferred from the app \u2014 pin with `qore-skills sync --features`" : ", pinned in the manifest"}).`
+  ];
+  const managedWrites = [...p.writes.keys()].filter((r) => r !== MANIFEST_PATH);
+  if (!managedWrites.length && !p.deletes.length && p.claudeMd === void 0) {
+    lines.push("", "No skill content changed.");
+  }
+  const section = (title, items, note) => {
+    if (!items.length) return;
+    lines.push("", `**${title}** ${note}`, "", ...items.map((i) => `- \`.claude/${i}\``));
+  };
+  section(
+    "Hand-edited managed files, overwritten",
+    p.edited,
+    "(the edit is in this change's diff; to keep it, move it into `.claude/qore/extensions/<skill>.md`):"
+  );
+  section("Existing files now managed", p.adopted, "(written by an older template; check the diff for local changes):");
+  section(
+    "Legacy skill directories removed",
+    p.legacyRemoved,
+    "(replaced by their `qore-*` names; a local edit to one is in this change's diff):"
+  );
+  if (p.claudeMd !== void 0) {
+    lines.push("", "**`CLAUDE.md`:**", "");
+    for (const [from, to] of p.claudeMdRenamed) lines.push(`- Renamed \`${from}\` to \`${to}\`.`);
+    if (p.claudeMdImportAdded) lines.push(`- Imports \`${CLAUDE_MD_IMPORT}\`, the index of managed skills.`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/cli/skills.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmdirSync, rmSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+var USAGE = `usage:
+  qore-skills sync   [--cwd <app>] [--features <json>|infer] [--report <file.md>]
+  qore-skills check  [--cwd <app>] [--json]
+  qore-skills render --features <json> --out <dir>`;
+var PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+function parseArgs(argv) {
+  const [cmd, ...rest] = argv;
+  if (cmd !== "sync" && cmd !== "check" && cmd !== "render") return { error: USAGE };
+  const args = { cmd, cwd: process.cwd(), json: false };
+  for (let i = 0; i < rest.length; i++) {
+    const flag = rest[i];
+    const value = () => {
+      const v = rest[++i];
+      if (v === void 0) throw new Error(`${flag} needs a value`);
+      return v;
+    };
+    try {
+      if (flag === "--cwd") args.cwd = resolve(value());
+      else if (flag === "--features") {
+        const v = value();
+        args.features = v === "infer" ? "infer" : parseFeatures(JSON.parse(v));
+      } else if (flag === "--report") args.report = resolve(value());
+      else if (flag === "--out") args.out = resolve(value());
+      else if (flag === "--json") args.json = true;
+      else return { error: `unknown option ${flag}
+${USAGE}` };
+    } catch (err) {
+      return { error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  if (cmd === "render" && (!args.features || args.features === "infer" || !args.out)) return { error: `render needs --features and --out
+${USAGE}` };
+  return args;
+}
+function walk(root, prefix = "") {
+  const dir = join(root, prefix);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).flatMap((d) => {
+    const rel = prefix ? `${prefix}/${d.name}` : d.name;
+    return d.isDirectory() ? walk(root, rel) : d.isFile() ? [rel] : [];
+  });
+}
+function loadSources(root = join(PACKAGE_ROOT, "skills")) {
+  const catalog = JSON.parse(readFileSync(join(root, "catalog.json"), "utf8"));
+  const sources = new Map(
+    walk(root).filter((rel) => rel !== "catalog.json").map((rel) => [rel, readFileSync(join(root, rel), "utf8").replace(/\r\n/g, "\n")])
+  );
+  return { catalog, sources };
+}
+function sdkVersion() {
+  return JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8")).version;
+}
+function readOptional(path) {
+  return existsSync(path) ? readFileSync(path, "utf8") : void 0;
+}
+function writeFile(path, text) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, text);
+}
+function pruneEmpty(root, rel, stop) {
+  let dir = dirname(join(root, rel));
+  while (dir.startsWith(join(root, stop)) && dir !== join(root, stop)) {
+    if (!existsSync(dir) || readdirSync(dir).length) return;
+    rmdirSync(dir);
+    dir = dirname(dir);
+  }
+}
+function plan(app, override) {
+  const claude = join(app, ".claude");
+  const manifestText = readOptional(join(claude, MANIFEST_PATH));
+  const manifest = manifestText ? parseManifest(manifestText) : null;
+  const featureOverride = override === "infer" ? void 0 : override ?? manifest?.featureOverride;
+  const pkg = JSON.parse(readOptional(join(app, "package.json")) ?? "{}");
+  const features = featureOverride ?? inferFeatures(pkg, (rel) => existsSync(join(app, rel)));
+  const inferred = !featureOverride;
+  const { catalog, sources } = loadSources();
+  return {
+    inferred,
+    plan: planSync({
+      catalog,
+      tree: buildTree(catalog, sources, features),
+      manifest,
+      sdkVersion: sdkVersion(),
+      features,
+      featureOverride,
+      read: (rel) => readOptional(join(claude, rel)),
+      listDir: (rel) => walk(join(claude, rel)).map((f) => `${rel}/${f}`),
+      claudeMd: readOptional(join(app, "CLAUDE.md"))
+    })
+  };
+}
+function apply(app, p) {
+  const claude = join(app, ".claude");
+  for (const rel of p.deletes) {
+    rmSync(join(claude, rel), { force: true });
+    pruneEmpty(claude, rel, "skills");
+  }
+  for (const [rel, text] of p.writes) writeFile(join(claude, rel), text);
+  if (p.claudeMd !== void 0) writeFileSync(join(app, "CLAUDE.md"), p.claudeMd);
+}
+function render(features, out) {
+  const { catalog, sources } = loadSources();
+  const tree = buildTree(catalog, sources, features);
+  for (const [rel, text] of tree) writeFile(join(out, rel), text);
+  const manifest = {
+    schemaVersion: 1,
+    sdkVersion: sdkVersion(),
+    features,
+    detached: [],
+    files: Object.fromEntries([...tree].map(([rel, c]) => [rel, hashContent(c)]))
+  };
+  writeFile(join(out, MANIFEST_PATH), renderManifest(manifest));
+}
+function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if ("error" in args) {
+    console.error(`qore-skills: ${args.error}`);
+    return 2;
+  }
+  if (args.cmd === "render") {
+    render(args.features, args.out);
+    console.log(`qore-skills: rendered into ${args.out}`);
+    return 0;
+  }
+  const { plan: p, inferred } = plan(args.cwd, args.features);
+  const report = renderReport(p, { inferred });
+  if (args.cmd === "check") {
+    const changed = planChanges(p);
+    if (args.json) {
+      console.log(
+        JSON.stringify({
+          upToDate: !changed,
+          writes: [...p.writes.keys()],
+          deletes: p.deletes,
+          edited: p.edited,
+          claudeMd: p.claudeMd !== void 0
+        })
+      );
+    } else {
+      console.log(changed ? report : "qore-skills: up to date");
+    }
+    return changed ? 1 : 0;
+  }
+  apply(args.cwd, p);
+  if (args.report) writeFile(args.report, report);
+  console.log(report);
+  return 0;
+}
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  try {
+    process.exitCode = main();
+  } catch (err) {
+    console.error(`qore-skills: ${err instanceof Error ? err.message : String(err)}`);
+    process.exitCode = 2;
+  }
+}
+
+// src/cli/skills-postinstall.ts
+var SDK = "@quatronic/sdk";
+function dependsOnSdk(dir) {
+  const path = join2(dir, "package.json");
+  if (!existsSync2(path)) return false;
+  if (existsSync2(join2(dir, "node_modules", ...SDK.split("/"), "package.json"))) return true;
+  try {
+    const pkg = JSON.parse(readFileSync2(path, "utf8"));
+    return Boolean(pkg.dependencies?.[SDK] ?? pkg.devDependencies?.[SDK]);
+  } catch {
+    return false;
+  }
+}
+function findApp(start) {
+  let dir = resolve2(start);
+  for (; ; ) {
+    if (dependsOnSdk(dir)) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function uncommittedEdits(p, manifestFiles, dirty, read) {
+  const touched = [...p.writes.keys(), ...p.deletes].filter((rel) => rel !== MANIFEST_PATH);
+  return touched.filter((rel) => dirty.has(`.claude/${rel}`)).filter((rel) => {
+    const disk = read(rel);
+    return disk !== void 0 && hashContent(disk) !== manifestFiles[rel];
+  }).map((rel) => `.claude/${rel}`).sort();
+}
+function runPostinstall(e) {
+  try {
+    if (e.env.QORE_SKILLS_SYNC === "0") return { kind: "disabled" };
+    if (e.env.CI) return { kind: "ci" };
+    if (!e.self.split(sep).includes("node_modules")) return { kind: "not-installed" };
+    const app = findApp(e.env.INIT_CWD ?? process.cwd());
+    if (!app) return { kind: "no-app" };
+    if (!existsSync2(join2(app, ".git"))) return { kind: "not-a-checkout" };
+    const manifestPath = join2(app, ".claude", MANIFEST_PATH);
+    const manifest = existsSync2(manifestPath) ? parseManifest(readFileSync2(manifestPath, "utf8")) : null;
+    if (manifest?.sdkVersion === e.sdkVersion) return { kind: "up-to-date" };
+    const { plan: p, inferred } = plan(app);
+    const dirty = e.gitDirty(app);
+    if (!dirty) return { kind: "failed", message: "git is not available to check for uncommitted edits" };
+    const read = (rel) => {
+      const path = join2(app, ".claude", rel);
+      return existsSync2(path) ? readFileSync2(path, "utf8") : void 0;
+    };
+    const paths = uncommittedEdits(p, manifest?.files ?? {}, dirty, read);
+    if (paths.length) return { kind: "dirty", app, paths };
+    apply(app, p);
+    return { kind: "synced", app, report: renderReport(p, { inferred }) };
+  } catch (err) {
+    return { kind: "failed", message: err instanceof Error ? err.message : String(err) };
+  }
+}
+function parseStatusZ(out) {
+  const paths = /* @__PURE__ */ new Set();
+  const entries = out.split("\0");
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.length < 4) continue;
+    paths.add(entry.slice(3));
+    if (entry[0] === "R" || entry[0] === "C") paths.add(entries[++i] ?? "");
+  }
+  return paths;
+}
+function gitDirty(app) {
+  try {
+    const top = execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd: app, encoding: "utf8" }).trim();
+    const out = execFileSync("git", ["status", "--porcelain", "-z", "--untracked-files=all", "--", "."], {
+      cwd: app,
+      encoding: "utf8"
+    });
+    const prefix = resolve2(app).slice(resolve2(top).length).replace(/^[\\/]/, "").replace(/\\/g, "/");
+    return new Set([...parseStatusZ(out)].map((p) => prefix && p.startsWith(`${prefix}/`) ? p.slice(prefix.length + 1) : p));
+  } catch {
+    return null;
+  }
+}
+function message(o) {
+  switch (o.kind) {
+    case "synced":
+      return `${o.report}
+qore-skills: commit .claude/ and CLAUDE.md together with this SDK bump.`;
+    case "dirty":
+      return "qore-skills: managed skills were NOT synced to this SDK version, because these files hold uncommitted edits:\n" + o.paths.map((p) => `  ${p}`).join("\n") + "\nMove each edit into .claude/qore/extensions/<skill>.md (see /qore-author-skill), then run `pnpm exec qore-skills sync`.";
+    case "failed":
+      return `qore-skills: skipped syncing managed skills (${o.message}). Run \`pnpm exec qore-skills sync\`.`;
+    default:
+      return void 0;
+  }
+}
+function main2() {
+  const self = realpathSync2(fileURLToPath2(import.meta.url));
+  const pkg = join2(dirname2(self), "..", "..", "package.json");
+  const sdkVersion2 = JSON.parse(readFileSync2(pkg, "utf8")).version;
+  const text = message(runPostinstall({ env: process.env, self, sdkVersion: sdkVersion2, gitDirty }));
+  if (text) console.error(text);
+}
+export {
+  findApp,
+  main2 as main,
+  message,
+  parseStatusZ,
+  runPostinstall,
+  uncommittedEdits
+};