@kb-labs/core-config 1.2.0 → 1.4.0

package/dist/index.js

@@ -1,30 +1,1534 @@
-// Core exports
-export * from './types/index';
-export * from './runtime';
-export * from './utils';
-export * from './utils/paths';
-// Enhanced config system exports
-export * from './errors/kb-error';
-export * from './cache/fs-cache';
-export * from './hash/config-hash';
-export * from './api/read-config';
-export * from './api/read-kb-config';
-export * from './merge/layered-merge';
-export * from './api/product-config';
-export * from './preset/resolve-preset';
-export * from './lockfile/lockfile';
-export * from './types/preset';
-export * from './profiles/types';
-export * from './profiles/loader';
-export * from './profiles/scope-selector';
-export * from './profiles/resolver';
-// Init system exports
-export * from './types/init';
-export * from './api/init-workspace';
-export * from './api/upsert-lockfile';
-export * from './utils/fs-atomic';
-// Re-export clearCaches for convenience
-export { clearCaches } from './cache/fs-cache';
-// Validation API
-export { validateProductConfig } from './validation/validate-config';
+import { KbError, ERROR_HINTS, ensureWithinWorkspace, writeFileAtomic } from './chunk-A2WE2JZW.js';
+export { ERROR_HINTS, KbError, ensureWithinWorkspace, getExitCode, writeFileAtomic } from './chunk-A2WE2JZW.js';
+import { promises } from 'fs';
+import path3, { extname } from 'path';
+import { createHash } from 'crypto';
+import YAML2 from 'yaml';
+import { z } from 'zod';
+import picomatch from 'picomatch';
+import { createRequire } from 'module';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+
+async function findNearestConfig(opts) {
+  const start = path3.resolve(opts.startDir ?? process.cwd());
+  const stop = opts.stopDir ? path3.resolve(opts.stopDir) : null;
+  const tried = [];
+  let dir = start;
+  while (true) {
+    for (const name of opts.filenames) {
+      const candidate = path3.join(dir, name);
+      tried.push(candidate);
+      try {
+        await promises.access(candidate);
+        return { path: candidate, tried };
+      } catch {
+      }
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    if (stop && (dir === stop || parent === stop)) {
+      break;
+    }
+    dir = parent;
+  }
+  return { path: null, tried };
+}
+async function readJsonWithDiagnostics(p) {
+  const diagnostics = [];
+  try {
+    const raw = await promises.readFile(p, "utf8");
+    try {
+      const data = JSON.parse(raw);
+      return { ok: true, data, diagnostics };
+    } catch (e) {
+      diagnostics.push({ level: "error", code: "JSON_PARSE_FAILED", message: `Failed to parse JSON: ${p}`, detail: String(e) });
+      return { ok: false, diagnostics };
+    }
+  } catch (e) {
+    diagnostics.push({ level: "error", code: "FILE_READ_FAILED", message: `Failed to read file: ${p}`, detail: String(e) });
+    return { ok: false, diagnostics };
+  }
+}
+function pickDefined(obj) {
+  if (!obj) {
+    return {};
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function mergeDefined(base, over) {
+  if (!over) {
+    return base;
+  }
+  if (Array.isArray(base) && Array.isArray(over)) {
+    return [...base, ...over.filter((v) => v !== void 0)];
+  }
+  if (isPlainObject(base) && isPlainObject(over)) {
+    const out = { ...base };
+    for (const [k, v] of Object.entries(over)) {
+      if (v === void 0) {
+        continue;
+      }
+      if (isPlainObject(base[k]) && isPlainObject(v)) {
+        out[k] = mergeDefined(base[k], v);
+      } else if (Array.isArray(base[k]) && Array.isArray(v)) {
+        out[k] = mergeDefined(base[k], v);
+      } else {
+        out[k] = v;
+      }
+    }
+    return out;
+  }
+  return over ?? base;
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && Object.getPrototypeOf(v) === Object.prototype;
+}
+var SYSTEM_DEFAULTS = {
+  profiles: { rootDir: ".kb/profiles", defaultName: "default", strict: true }
+};
+function resolveConfig(args) {
+  const diagnostics = [];
+  const envPart = args.envMapper?.(process.env) ?? {};
+  const merged = mergeDefined(
+    mergeDefined(
+      mergeDefined(mergeDefined(structuredClone(SYSTEM_DEFAULTS), structuredClone(args.defaults)), args.fileConfig),
+      envPart
+    ),
+    args.cliOverrides
+  );
+  if (args.validate) {
+    const res = args.validate(merged);
+    if (!res.ok) {
+      diagnostics.push({ level: "error", code: "CONFIG_VALIDATION_FAILED", message: "Configuration did not pass validation." });
+      if (res.diagnostics) {
+        diagnostics.push(...res.diagnostics);
+      }
+    } else if (res.diagnostics?.length) {
+      diagnostics.push(...res.diagnostics);
+    }
+  }
+  return { value: merged, diagnostics };
+}
+
+// src/utils/env.ts
+function toBool(v) {
+  if (v === void 0) {
+    return void 0;
+  }
+  const s = v.trim().toLowerCase();
+  if (s === "1" || s === "true" || s === "yes" || s === "on") {
+    return true;
+  }
+  if (s === "0" || s === "false" || s === "no" || s === "off") {
+    return false;
+  }
+  return void 0;
+}
+function toInt(v) {
+  if (v === void 0) {
+    return void 0;
+  }
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+
+// src/utils/product-normalize.ts
+var FS_MAP = /* @__PURE__ */ new Map([
+  ["aiReview", "ai-review"],
+  ["aiDocs", "ai-docs"],
+  ["devlink", "devlink"],
+  ["release", "release"],
+  ["devkit", "devkit"],
+  ["mind", "mind"],
+  ["workflow", "workflow"],
+  ["analytics", "analytics"]
+]);
+function toFsProduct(id) {
+  return FS_MAP.get(id) ?? id;
+}
+function toConfigProduct(fsKey) {
+  for (const [k, v] of FS_MAP) {
+    if (v === fsKey) {
+      return k;
+    }
+  }
+  return fsKey;
+}
+function isValidProductId(value) {
+  return FS_MAP.has(value);
+}
+function getAllProductIds() {
+  return Array.from(FS_MAP.keys());
+}
+function getProfilesRootDir(cwd) {
+  return path3.join(cwd, ".kb", "profiles");
+}
+function getProductConfigDir(cwd, fsProduct) {
+  return path3.join(cwd, ".kb", fsProduct);
+}
+function getProductConfigPath(cwd, fsProduct) {
+  return path3.join(getProductConfigDir(cwd, fsProduct), `${fsProduct}.config.json`);
+}
+function getKbRootDir(cwd) {
+  return path3.join(cwd, ".kb");
+}
+function getLockfilePath(cwd) {
+  return path3.join(getKbRootDir(cwd), "lock.json");
+}
+var LRUCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+};
+var FSCache = class {
+  cache = new LRUCache(100);
+  keyCache = new LRUCache(100);
+  /**
+   * Generate cache key from file path, mtime, and size
+   */
+  async getCacheKey(absPath) {
+    const keyStr = `key:${absPath}`;
+    let key = this.keyCache.get(keyStr);
+    if (!key) {
+      try {
+        const stats = await promises.stat(absPath);
+        key = {
+          absPath,
+          mtime: stats.mtime.getTime(),
+          size: stats.size
+        };
+        this.keyCache.set(keyStr, key);
+      } catch {
+        return { absPath, mtime: 0, size: 0 };
+      }
+    }
+    return key;
+  }
+  /**
+   * Get cached file data if available and not stale
+   */
+  async get(absPath) {
+    const key = await this.getCacheKey(absPath);
+    const cacheKey = `${key.absPath}|${key.mtime}|${key.size}`;
+    const entry = this.cache.get(cacheKey);
+    if (!entry) {
+      return null;
+    }
+    try {
+      const stats = await promises.stat(absPath);
+      if (stats.mtime.getTime() !== key.mtime || stats.size !== key.size) {
+        this.cache.delete(cacheKey);
+        const newKey = {
+          absPath,
+          mtime: stats.mtime.getTime(),
+          size: stats.size
+        };
+        this.keyCache.set(`key:${absPath}`, newKey);
+        return null;
+      }
+    } catch {
+      this.cache.delete(cacheKey);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * Cache file data
+   */
+  async set(absPath, data) {
+    const key = await this.getCacheKey(absPath);
+    const cacheKey = `${key.absPath}|${key.mtime}|${key.size}`;
+    this.cache.set(cacheKey, {
+      data,
+      mtime: key.mtime,
+      size: key.size,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Clear all caches
+   */
+  clearCaches() {
+    this.cache.clear();
+    this.keyCache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      size: this.cache.size(),
+      keySize: this.keyCache.size()
+    };
+  }
+};
+var fsCache = new FSCache();
+function clearCaches() {
+  fsCache.clearCaches();
+}
+function computeConfigHash(obj) {
+  const normalized = normalizeForHash(obj);
+  const json = JSON.stringify(normalized, null, 0);
+  return createHash("sha256").update(json, "utf8").digest("hex");
+}
+function normalizeForHash(obj) {
+  if (obj === null || obj === void 0) {
+    return null;
+  }
+  if (typeof obj !== "object") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(normalizeForHash);
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const normalized = {};
+  for (const key of sortedKeys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      normalized[key] = normalizeForHash(value);
+    }
+  }
+  return normalized;
+}
+function computeConfigsHash(configs) {
+  const combined = configs.reduce((acc, config) => {
+    return { ...acc, ...config };
+  }, {});
+  return computeConfigHash(combined);
+}
+async function readConfigFile(filePath) {
+  const absPath = path3.resolve(filePath);
+  const cached = await fsCache.get(absPath);
+  if (cached !== null) {
+    return cached;
+  }
+  try {
+    const raw = await promises.readFile(absPath, "utf-8");
+    const ext = extname(absPath).toLowerCase();
+    let data;
+    let format;
+    if (ext === ".yaml" || ext === ".yml") {
+      data = YAML2.parse(raw);
+      format = "yaml";
+    } else {
+      data = JSON.parse(raw);
+      format = "json";
+    }
+    const result = { data, format, path: absPath };
+    await fsCache.set(absPath, result);
+    return result;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new KbError(
+        "ERR_CONFIG_INVALID",
+        `Failed to parse config file: ${filePath}`,
+        ERROR_HINTS.ERR_CONFIG_INVALID,
+        { filePath, error: error.message }
+      );
+    }
+    throw new KbError(
+      "ERR_CONFIG_NOT_FOUND",
+      `Config file not found: ${filePath}`,
+      ERROR_HINTS.ERR_CONFIG_NOT_FOUND,
+      { filePath, error: error instanceof Error ? error.message : String(error) }
+    );
+  }
+}
+async function findNearestConfig2(startDir, filenames = []) {
+  const start = path3.resolve(startDir);
+  const tried = [];
+  let dir = start;
+  const defaultFilenames = [
+    ".kb/kb.config.yaml",
+    ".kb/kb.config.yml",
+    ".kb/kb.config.json"
+  ];
+  const searchFilenames = filenames.length > 0 ? filenames : defaultFilenames;
+  while (true) {
+    for (const filename of searchFilenames) {
+      const candidate = path3.join(dir, filename);
+      tried.push(candidate);
+      try {
+        await promises.access(candidate);
+        return { path: candidate, tried };
+      } catch {
+      }
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return { path: null, tried };
+}
+async function findGitRoot(startDir) {
+  let dir = path3.resolve(startDir);
+  while (true) {
+    try {
+      await promises.access(path3.join(dir, ".git"));
+      return dir;
+    } catch {
+      const parent = path3.dirname(dir);
+      if (parent === dir) {
+        break;
+      }
+      dir = parent;
+    }
+  }
+  return null;
+}
+async function readWorkspaceConfig(cwd) {
+  const { path: configPath } = await findNearestConfig2(cwd);
+  if (!configPath) {
+    return null;
+  }
+  return readConfigFile(configPath);
+}
+var KB_CONFIG_FILENAMES = [
+  "kb.config.json",
+  "kb.config.yaml",
+  "kb.config.yml",
+  ".kb/kb.config.json",
+  ".kb/kb.config.yaml",
+  ".kb/kb.config.yml"
+];
+async function findKbConfig(cwd, filenames = KB_CONFIG_FILENAMES) {
+  const tried = [];
+  const gitRoot = await findGitRoot(cwd);
+  const stopDir = gitRoot || path3.parse(cwd).root;
+  let dir = path3.resolve(cwd);
+  while (true) {
+    for (const filename of filenames) {
+      const candidate = path3.join(dir, filename);
+      tried.push(candidate);
+      try {
+        await promises.access(candidate);
+        return { path: candidate, tried };
+      } catch {
+      }
+    }
+    if (dir === stopDir || dir === path3.dirname(dir)) {
+      break;
+    }
+    dir = path3.dirname(dir);
+  }
+  return { path: null, tried };
+}
+async function readKbConfig(cwd) {
+  const { path: path12 } = await findKbConfig(cwd);
+  if (!path12) {
+    return null;
+  }
+  return readConfigFile(path12);
+}
+
+// src/merge/layered-merge.ts
+function layeredMergeWithTrace(layers) {
+  const trace = [];
+  const isPlainObject2 = (v) => v && typeof v === "object" && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
+  const merge = (base, overlay, layer, path12 = []) => {
+    if (Array.isArray(base) && Array.isArray(overlay)) {
+      trace.push({
+        path: path12.join("."),
+        source: layer.source,
+        type: "overwriteArray",
+        layer: layer.label,
+        profileRef: layer.source.includes("profile") ? extractProfileRef(layer.source) : void 0,
+        presetRef: layer.source.includes("preset") ? extractPresetRef(layer.source) : void 0,
+        version: extractVersion(layer.source)
+      });
+      return overlay;
+    }
+    if (isPlainObject2(base) && isPlainObject2(overlay)) {
+      const result = { ...base };
+      for (const [key, value] of Object.entries(overlay)) {
+        if (key in base) {
+          result[key] = merge(base[key], value, layer, [...path12, key]);
+        } else {
+          trace.push({
+            path: [...path12, key].join("."),
+            source: layer.source,
+            type: "set",
+            layer: layer.label,
+            profileRef: layer.source.includes("profile") ? extractProfileRef(layer.source) : void 0,
+            presetRef: layer.source.includes("preset") ? extractPresetRef(layer.source) : void 0,
+            version: extractVersion(layer.source)
+          });
+          result[key] = value;
+        }
+      }
+      return result;
+    }
+    trace.push({
+      path: path12.join("."),
+      source: layer.source,
+      type: "set",
+      layer: layer.label,
+      profileRef: layer.source.includes("profile") ? extractProfileRef(layer.source) : void 0,
+      presetRef: layer.source.includes("preset") ? extractPresetRef(layer.source) : void 0,
+      version: extractVersion(layer.source)
+    });
+    return overlay ?? base;
+  };
+  const merged = layers.reduce((acc, layer) => {
+    return merge(acc, layer.value, layer);
+  }, {});
+  return { merged, trace };
+}
+function extractProfileRef(source) {
+  const match = source.match(/profile[^:]*:[^@]+@(.+)/);
+  return match?.[1];
+}
+function extractPresetRef(source) {
+  const match = source.match(/preset[^:]*:@(.+)/);
+  return match?.[1];
+}
+function extractVersion(source) {
+  const match = source.match(/@([^:]+)/);
+  return match?.[1];
+}
+async function resolvePreset(presetRef, cwd) {
+  const [name, version] = parsePresetRef(presetRef);
+  const localPath = path3.join(cwd, "node_modules", name);
+  try {
+    const presetInfo = await loadPresetFromPath(localPath, name, version);
+    if (presetInfo) {
+      return presetInfo;
+    }
+  } catch {
+  }
+  throw new KbError(
+    "ERR_PRESET_NOT_RESOLVED",
+    `Preset not found: ${presetRef}`,
+    ERROR_HINTS.ERR_PRESET_NOT_RESOLVED,
+    { presetRef, cwd }
+  );
+}
+function parsePresetRef(presetRef) {
+  const atIndex = presetRef.lastIndexOf("@");
+  if (atIndex === -1) {
+    throw new KbError(
+      "ERR_PRESET_REF_INVALID",
+      `Invalid preset reference: ${presetRef}`,
+      "Preset references must include version (e.g., @kb-labs/org-preset@1.3.2)",
+      { presetRef }
+    );
+  }
+  const name = presetRef.substring(0, atIndex);
+  const version = presetRef.substring(atIndex + 1);
+  if (!name || !version) {
+    throw new KbError(
+      "ERR_PRESET_REF_INVALID",
+      `Invalid preset reference: ${presetRef}`,
+      "Preset references must include both name and version",
+      { presetRef }
+    );
+  }
+  return [name, version];
+}
+async function loadPresetFromPath(presetPath, name, version) {
+  try {
+    await promises.access(presetPath);
+    const packageJsonPath = path3.join(presetPath, "package.json");
+    const packageJson = JSON.parse(await promises.readFile(packageJsonPath, "utf-8"));
+    if (!versionMatches(packageJson.version, version)) {
+      return null;
+    }
+    const configPath = path3.join(presetPath, "config.defaults.json");
+    const config = JSON.parse(await promises.readFile(configPath, "utf-8"));
+    return {
+      name,
+      version: packageJson.version,
+      path: presetPath,
+      config
+    };
+  } catch {
+    return null;
+  }
+}
+function versionMatches(actualVersion, requiredVersion) {
+  if (requiredVersion.startsWith("^")) {
+    const major = requiredVersion.substring(1).split(".")[0];
+    const actualMajor = actualVersion.split(".")[0];
+    return major === actualMajor;
+  }
+  return actualVersion === requiredVersion;
+}
+function getPresetConfigForProduct(preset, product) {
+  const fsProduct = toFsProduct(product);
+  return preset.config.products?.[fsProduct] || {};
+}
+function getPresetMetadata(preset) {
+  return {
+    name: preset.name,
+    version: preset.version,
+    path: preset.path,
+    products: Object.keys(preset.config.products || {})
+  };
+}
+async function readLockfile(cwd) {
+  const lockfilePath = path3.join(cwd, ".kb", "lock.json");
+  try {
+    const lockfileData = await promises.readFile(lockfilePath, "utf-8");
+    return JSON.parse(lockfileData);
+  } catch {
+    const oldLockfilePath = path3.join(cwd, ".kb", "lockfile.json");
+    try {
+      const lockfileData = await promises.readFile(oldLockfilePath, "utf-8");
+      return JSON.parse(lockfileData);
+    } catch {
+      return null;
+    }
+  }
+}
+function stableStringify(obj, space = 2) {
+  return JSON.stringify(obj, (key, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return Object.keys(value).sort().reduce((sorted, key2) => {
+        sorted[key2] = value[key2];
+        return sorted;
+      }, {});
+    }
+    return value;
+  }, space);
+}
+async function writeLockfile(cwd, lockfileData) {
+  const lockfileDir = path3.join(cwd, ".kb");
+  const lockfilePath = path3.join(lockfileDir, "lock.json");
+  await promises.mkdir(lockfileDir, { recursive: true });
+  if (!lockfileData.$schema) {
+    lockfileData.$schema = "https://schemas.kb-labs.dev/lockfile.schema.json";
+  }
+  const { writeFileAtomic: writeFileAtomic2 } = await import('./fs-atomic-EKSZ6G5A.js');
+  await writeFileAtomic2(lockfilePath, stableStringify(lockfileData, 2) + "\n");
+}
+async function updateLockfile(cwd, updates) {
+  const existing = await readLockfile(cwd);
+  const lockfileData = {
+    $schema: "https://schemas.kb-labs.dev/lockfile.schema.json",
+    schemaVersion: "1.0",
+    orgPreset: updates.orgPreset || existing?.orgPreset,
+    profile: updates.profile || existing?.profile,
+    policyBundle: updates.policyBundle || existing?.policyBundle,
+    hashes: { ...existing?.hashes },
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (updates.configHashes) {
+    for (const [product, config] of Object.entries(updates.configHashes)) {
+      const fsProduct = toFsProduct(product);
+      const hash = computeConfigHash(config);
+      lockfileData.hashes[fsProduct] = hash;
+    }
+  }
+  await writeLockfile(cwd, lockfileData);
+  return lockfileData;
+}
+function getLockfileConfigHash(product, config) {
+  return computeConfigHash(config);
+}
+async function isLockfileUpToDate(cwd, configs) {
+  const lockfile = await readLockfile(cwd);
+  if (!lockfile) {
+    return false;
+  }
+  for (const [product, config] of Object.entries(configs)) {
+    const fsProduct = toFsProduct(product);
+    const currentHash = computeConfigHash(config);
+    const lockfileHash = lockfile.hashes[fsProduct];
+    if (currentHash !== lockfileHash) {
+      return false;
+    }
+  }
+  return true;
+}
+function validateLockfile(lockfileData) {
+  if (!lockfileData || typeof lockfileData !== "object") {
+    return false;
+  }
+  if (lockfileData.schemaVersion !== "1.0") {
+    return false;
+  }
+  if (!lockfileData.hashes || typeof lockfileData.hashes !== "object") {
+    return false;
+  }
+  if (!lockfileData.generatedAt || typeof lockfileData.generatedAt !== "string") {
+    return false;
+  }
+  return true;
+}
+function getLockfileStats(lockfileData) {
+  return {
+    productCount: Object.keys(lockfileData.hashes).length,
+    hasOrgPreset: !!lockfileData.orgPreset,
+    hasProfile: !!lockfileData.profile,
+    hasPolicyBundle: !!lockfileData.policyBundle,
+    generatedAt: new Date(lockfileData.generatedAt)
+  };
+}
+
+// src/api/product-config.ts
+async function getProductConfig(opts, schema) {
+  const { cwd, product, cli = {}, writeFinal = false, profileLayer } = opts;
+  const fsProduct = toFsProduct(product);
+  const workspaceConfig = await readWorkspaceConfig(cwd);
+  const layers = [];
+  layers.push({
+    label: "runtime",
+    value: getRuntimeDefaults(product),
+    source: "runtime:defaults"
+  });
+  if (profileLayer && profileLayer.products) {
+    const profileOverlay = profileLayer.products;
+    layers.push({
+      label: "profile",
+      value: profileOverlay,
+      source: profileLayer.source
+    });
+    if (profileLayer.scope && profileLayer.scope.products) {
+      const scopeOverlay = profileLayer.scope.products;
+      layers.push({
+        label: "profile-scope",
+        value: scopeOverlay,
+        source: profileLayer.scope.source
+      });
+    }
+  } else {
+    layers.push({
+      label: "profile",
+      value: {},
+      source: "profile:none"
+    });
+  }
+  let presetConfig = {};
+  if (workspaceConfig?.data) {
+    const workspaceData = workspaceConfig.data;
+    if (workspaceData.$extends) {
+      try {
+        const preset = await resolvePreset(workspaceData.$extends, cwd);
+        presetConfig = getPresetConfigForProduct(preset, product);
+        layers.push({
+          label: "preset",
+          value: presetConfig,
+          source: `preset:${workspaceData.$extends}`
+        });
+      } catch (error) {
+        console.warn(`Warning: Could not resolve preset ${workspaceData.$extends}:`, error);
+      }
+    }
+  }
+  if (Object.keys(presetConfig).length === 0) {
+    layers.push({
+      label: "preset",
+      value: {},
+      source: "preset:none"
+    });
+  }
+  if (workspaceConfig?.data) {
+    const workspaceData = workspaceConfig.data?.products?.[fsProduct] || {};
+    layers.push({
+      label: "workspace",
+      value: workspaceData,
+      source: "workspace:kb-labs.config"
+    });
+  }
+  const localConfigPath = path3.join(cwd, ".kb", fsProduct, `${fsProduct}.config.json`);
+  try {
+    const localConfig = await promises.readFile(localConfigPath, "utf-8");
+    const localData = JSON.parse(localConfig);
+    layers.push({
+      label: "local",
+      value: localData,
+      source: `local:.kb/${fsProduct}/${fsProduct}.config.json`
+    });
+  } catch {
+  }
+  if (Object.keys(cli).length > 0) {
+    layers.push({
+      label: "cli",
+      value: cli,
+      source: "cli:overrides"
+    });
+  }
+  const { merged, trace } = layeredMergeWithTrace(layers);
+  if (writeFinal) {
+    await writeFinalConfig(cwd, fsProduct, merged);
+  }
+  try {
+    const configHash = computeConfigHash(merged);
+    const configHashes = {};
+    configHashes[product] = configHash;
+    await updateLockfile(cwd, {
+      configHashes
+    });
+  } catch (error) {
+    console.warn("Warning: Could not update lockfile:", error);
+  }
+  return {
+    config: merged,
+    trace
+  };
+}
+async function explainProductConfig(opts, schema) {
+  const result = await getProductConfig(opts);
+  return { trace: result.trace };
+}
+function getRuntimeDefaults(product) {
+  const defaults = {
+    devlink: {
+      watch: true,
+      build: true
+    },
+    release: {
+      registry: "https://registry.npmjs.org",
+      strategy: "semver",
+      bump: "auto",
+      strict: true,
+      verify: ["audit", "build", "tests"],
+      publish: { npm: true, github: false },
+      rollback: { enabled: true, maxHistory: 5 },
+      output: { json: true, md: true, text: true },
+      changelog: {
+        enabled: true,
+        includeTypes: ["feat", "fix", "perf", "refactor", "revert"],
+        excludeTypes: ["chore", "ci"],
+        ignoreAuthors: ["dependabot", "renovate", "github-actions[bot]", "*[bot]"],
+        collapseMerges: true,
+        collapseReverts: true,
+        preferMergeSummary: true,
+        bumpStrategy: "independent",
+        workspace: true,
+        perPackage: true,
+        format: "both",
+        level: "standard",
+        locale: "en",
+        cache: true,
+        requireAudit: true,
+        requireSignedTags: false,
+        redactPatterns: ["(?i)token=\\w+", "(?i)apikey=\\w+", "(https?://[^\\s]+@[^\\s]+)", "(gh[ps]_[A-Za-z0-9_]+)"],
+        maxBodyLength: 500,
+        ignoreSubmodules: true
+      },
+      git: {
+        provider: "auto",
+        autoUnshallow: false
+      }
+    },
+    aiReview: {
+      enabled: true,
+      rules: []
+    },
+    aiDocs: {
+      enabled: true,
+      templates: []
+    },
+    devkit: {
+      sync: true,
+      check: true
+    },
+    analytics: {
+      enabled: true,
+      sinks: [],
+      buffer: {}
+    }
+  };
+  return defaults[product] || {};
+}
+async function writeFinalConfig(cwd, fsProduct, config) {
+  const configDir = path3.join(cwd, ".kb", fsProduct);
+  const configPath = path3.join(configDir, `${fsProduct}.config.json`);
+  await promises.mkdir(configDir, { recursive: true });
+  const finalConfig = {
+    $schema: "https://schemas.kb-labs.dev/config.schema.json",
+    schemaVersion: "1.0",
+    ...config
+  };
+  await promises.writeFile(configPath, JSON.stringify(finalConfig, null, 2));
+}
+function getConfigHash(config) {
+  return computeConfigHash(config);
+}
+var GlobSchema = z.string().min(1, "Glob pattern must be a non-empty string");
+var ProductOverridesSchema = z.record(z.string(), z.unknown());
+var ProductsMapSchema = z.record(z.string(), ProductOverridesSchema);
+var ScopeV2Schema = z.object({
+  id: z.string().min(1, "Scope id is required"),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  include: z.array(GlobSchema).min(1, "include requires at least one glob"),
+  exclude: z.array(GlobSchema).optional(),
+  products: ProductsMapSchema.optional(),
+  default: z.boolean().optional()
+});
+var ProfileMetaSchema = z.object({
+  version: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  deprecated: z.boolean().optional(),
+  owner: z.string().optional()
+}).strict();
+var ProfileV2Schema = z.object({
+  id: z.string().min(1, "Profile id is required"),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  extends: z.string().min(1, "extends must reference another profile id or preset").optional(),
+  scopes: z.array(ScopeV2Schema).optional(),
+  products: ProductsMapSchema.optional(),
+  meta: ProfileMetaSchema.optional()
+});
+var ProfilesV2Schema = z.array(ProfileV2Schema);
+var ResolvedScopeSchema = z.object({
+  id: z.string(),
+  label: z.string().optional(),
+  description: z.string().optional(),
+  include: z.array(z.string()),
+  exclude: z.array(z.string()).optional(),
+  isDefault: z.boolean(),
+  products: ProductsMapSchema.optional()
+});
+var BundleProfileSourceSchema = z.enum(["workspace", "preset", "npm", "implicit"]);
+var ProfileTraceSchema = z.object({
+  extends: z.array(z.string()).optional(),
+  overrides: z.array(z.string()).optional()
+});
+var ScopeSelectionSchema = z.object({
+  strategy: z.enum(["explicit", "default", "auto", "none"]),
+  path: z.string().optional()
+});
+var BundleProfileSchema = z.object({
+  id: z.string(),
+  key: z.string().optional(),
+  label: z.string().optional(),
+  name: z.string().optional(),
+  version: z.string().optional(),
+  source: BundleProfileSourceSchema,
+  scopes: z.array(ResolvedScopeSchema),
+  products: ProductsMapSchema.optional(),
+  trace: ProfileTraceSchema.optional(),
+  meta: ProfileMetaSchema.optional(),
+  productsByScope: z.record(z.string(), ProductsMapSchema).optional(),
+  activeScopeId: z.string().optional(),
+  activeScope: ResolvedScopeSchema.optional(),
+  scopeSelection: ScopeSelectionSchema.optional()
+});
+
+// src/profiles/loader.ts
+async function readProfilesSection(cwd) {
+  const kbConfig = await readKbConfig(cwd);
+  if (!kbConfig?.data) {
+    return { profiles: [] };
+  }
+  const rawProfiles = kbConfig.data?.profiles;
+  if (rawProfiles === void 0) {
+    return {
+      profiles: [],
+      sourcePath: kbConfig.path,
+      format: kbConfig.format
+    };
+  }
+  const parsed = ProfilesV2Schema.safeParse(rawProfiles);
+  if (!parsed.success) {
+    throw new KbError(
+      "ERR_PROFILE_INVALID_FORMAT",
+      "Invalid profiles[] section in kb.config.",
+      ERROR_HINTS.ERR_PROFILE_INVALID_FORMAT,
+      {
+        issues: parsed.error.issues,
+        sourcePath: kbConfig.path
+      }
+    );
+  }
+  return {
+    profiles: parsed.data,
+    sourcePath: kbConfig.path,
+    format: kbConfig.format
+  };
+}
+function selectProfileScope(opts) {
+  const scopes = opts.bundleProfile.scopes || [];
+  if (scopes.length === 0) {
+    return { strategy: "none" };
+  }
+  if (opts.scopeId) {
+    const scope = scopes.find((s) => s.id === opts.scopeId);
+    if (!scope) {
+      throw new KbError(
+        "ERR_PROFILE_SCOPE_NOT_FOUND",
+        `Scope "${opts.scopeId}" not found in profile "${opts.bundleProfile.id}"`,
+        ERROR_HINTS.ERR_PROFILE_SCOPE_NOT_FOUND,
+        { scopeId: opts.scopeId, available: scopes.map((s) => s.id) }
+      );
+    }
+    return { scope, strategy: "explicit" };
+  }
+  const defaults = scopes.filter((s) => s.isDefault);
+  if (defaults.length > 1) {
+    throw new KbError(
+      "ERR_PROFILE_SCOPE_CONFLICT",
+      `Multiple default scopes found in profile "${opts.bundleProfile.id}"`,
+      ERROR_HINTS.ERR_PROFILE_SCOPE_CONFLICT,
+      { scopes: defaults.map((s) => s.id) }
+    );
+  }
+  if (defaults.length === 1) {
+    return { scope: defaults[0], strategy: "default" };
+  }
+  const relativePath = normalizePath(
+    path3.relative(opts.cwd, opts.executionPath)
+  );
+  const matches = scopes.filter(
+    (scope) => scopeMatchesPath(scope, relativePath)
+  );
+  if (matches.length > 1) {
+    throw new KbError(
+      "ERR_PROFILE_SCOPE_CONFLICT",
+      `Multiple scopes match path "${relativePath}"`,
+      ERROR_HINTS.ERR_PROFILE_SCOPE_CONFLICT,
+      { scopes: matches.map((s) => s.id), path: relativePath }
+    );
+  }
+  if (matches.length === 1) {
+    return { scope: matches[0], strategy: "auto", matchedPath: relativePath };
+  }
+  return { strategy: "none" };
+}
+function scopeMatchesPath(scope, candidate) {
+  const includes = scope.include && scope.include.length > 0 ? scope.include : ["**/*"];
+  const excludeGlobs = scope.exclude || [];
+  const tester = (glob) => picomatch(glob, { dot: true, nocase: false })(candidate);
+  const includeMatched = candidate === "." || includes.some((glob) => tester(adjustGlob(glob)));
+  if (!includeMatched) {
+    return false;
+  }
+  const excludeMatched = excludeGlobs.some(
+    (glob) => tester(adjustGlob(glob))
+  );
+  return !excludeMatched;
+}
+function normalizePath(p) {
+  if (!p || p === ".") {
+    return ".";
+  }
+  const normalized = p.split(path3.sep).join("/");
+  return normalized || ".";
+}
+function adjustGlob(glob) {
+  if (!glob) {
+    return "**/*";
+  }
+  return glob;
+}
+var requireFromHere = createRequire(import.meta.url);
+function clone(value) {
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+async function resolveProfile(opts) {
+  const localProfilesResult = await readProfilesSection(opts.cwd);
+  const localProfiles = localProfilesResult.profiles;
+  const localPath = localProfilesResult.sourcePath;
+  const profileMap = new Map(localProfiles.map((p) => [p.id, p]));
+  const cache = /* @__PURE__ */ new Map();
+  if (localPath) {
+    for (const profile of localProfiles) {
+      cache.set(profile.id, {
+        profile: clone(profile),
+        source: "workspace",
+        sourcePath: localPath
+      });
+    }
+  }
+  const chain = await resolveProfileChain(
+    opts.profileId,
+    cache,
+    profileMap,
+    opts.cwd,
+    /* @__PURE__ */ new Set()
+  );
+  if (chain.length === 0) {
+    throw new KbError(
+      "ERR_PROFILE_NOT_DEFINED",
+      `Profile "${opts.profileId}" not found`,
+      ERROR_HINTS.ERR_PROFILE_NOT_DEFINED,
+      {
+        profileId: opts.profileId,
+        available: Array.from(profileMap.keys())
+      }
+    );
+  }
+  const bundleProfile = mergeProfileChain(chain);
+  const productsByScope = buildScopeProductMap(bundleProfile, chain);
+  bundleProfile.productsByScope = productsByScope;
+  return bundleProfile;
+}
+async function resolveProfileChain(reference, cache, localProfiles, cwd, seen) {
+  const key = reference;
+  if (seen.has(key)) {
+    throw new KbError(
+      "ERR_PROFILE_EXTENDS_FAILED",
+      `Circular profile extends detected at "${reference}"`,
+      ERROR_HINTS.ERR_PROFILE_EXTENDS_FAILED,
+      { reference, chain: Array.from(seen) }
+    );
+  }
+  seen.add(key);
+  let layer = cache.get(reference);
+  if (!layer) {
+    if (localProfiles.has(reference)) {
+      layer = {
+        profile: clone(localProfiles.get(reference)),
+        source: "workspace"
+      };
+    } else if (isPackageReference(reference)) {
+      layer = await loadPackageProfile(reference, cwd);
+    } else {
+      throw new KbError(
+        "ERR_PROFILE_NOT_DEFINED",
+        `Profile "${reference}" not found`,
+        ERROR_HINTS.ERR_PROFILE_NOT_DEFINED,
+        { reference, available: Array.from(localProfiles.keys()) }
+      );
+    }
+    cache.set(reference, layer);
+  }
+  const result = [];
+  if (layer.profile.extends) {
+    const parentChain = await resolveProfileChain(
+      layer.profile.extends,
+      cache,
+      localProfiles,
+      cwd,
+      seen
+    );
+    result.push(...parentChain);
+  }
+  result.push(layer);
+  seen.delete(key);
+  return result;
+}
+function mergeProfileChain(chain) {
+  const mergedProducts = {};
+  let mergedMeta;
+  let mergedLabel;
+  let mergedDescription;
+  let mergedVersion;
+  let scopes = [];
+  let scopesDefined = false;
+  for (const layer of chain) {
+    const profile = layer.profile;
+    mergedLabel = profile.label ?? mergedLabel;
+    mergedDescription = profile.description ?? mergedDescription;
+    mergedVersion = profile.meta?.version ?? mergedVersion;
+    mergedMeta = mergeMeta(mergedMeta, profile.meta);
+    if (profile.products) {
+      for (const [productKey, overrides] of Object.entries(profile.products)) {
+        if (!matchedProductOverrides(overrides)) {
+          continue;
+        }
+        const target = mergedProducts[productKey] ??= {};
+        Object.assign(target, clone(overrides));
+      }
+    }
+    if (profile.scopes && profile.scopes.length > 0) {
+      scopes = clone(profile.scopes);
+      scopesDefined = true;
+    } else if (!scopesDefined && profile.scopes) {
+      scopes = clone(profile.scopes);
+    }
+  }
+  const finalLayer = chain[chain.length - 1];
+  if (!finalLayer) {
+    throw new KbError(
+      "ERR_PROFILE_NOT_DEFINED",
+      "Profile chain is empty",
+      ERROR_HINTS.ERR_PROFILE_NOT_DEFINED
+    );
+  }
+  const finalId = finalLayer.profile.id;
+  const finalSource = finalLayer.source;
+  const bundleProfile = {
+    id: finalId,
+    key: finalId,
+    label: mergedLabel,
+    name: mergedLabel ?? finalId,
+    version: mergedVersion,
+    source: finalSource,
+    scopes: scopes.map((scope) => ({
+      id: scope.id,
+      label: scope.label,
+      description: scope.description,
+      include: scope.include,
+      exclude: scope.exclude,
+      isDefault: !!scope.default,
+      products: scope.products ? clone(scope.products) : void 0
+    })),
+    products: Object.keys(mergedProducts).length ? mergedProducts : void 0,
+    trace: buildTrace(chain),
+    meta: mergedMeta,
+    productsByScope: {}
+  };
+  return bundleProfile;
+}
+function buildScopeProductMap(bundleProfile, chain) {
+  const map = {};
+  for (const scope of bundleProfile.scopes) {
+    map[scope.id] = {};
+    for (const layer of chain) {
+      const matchingScope = layer.profile.scopes?.find((s) => s.id === scope.id);
+      if (!matchingScope?.products) {
+        continue;
+      }
+      for (const [productKey, overrides] of Object.entries(matchingScope.products)) {
+        if (!matchedProductOverrides(overrides)) {
+          continue;
+        }
+        const scopeMap = map[scope.id];
+        if (!scopeMap) {
+          continue;
+        }
+        const target = scopeMap[productKey];
+        if (!target) {
+          scopeMap[productKey] = clone(overrides);
+        } else {
+          Object.assign(target, clone(overrides));
+        }
+      }
+    }
+  }
+  return map;
+}
+function matchedProductOverrides(overrides) {
+  return overrides !== null && typeof overrides === "object";
+}
+function buildTrace(chain) {
+  if (chain.length <= 1) {
+    return void 0;
+  }
+  const extendsList = chain.slice(0, -1).map((layer) => {
+    if (typeof layer.source === "string" && layer.source.startsWith("npm:")) {
+      return layer.source;
+    }
+    return `${layer.source}:${layer.profile.id}`;
+  });
+  return {
+    extends: extendsList
+  };
+}
+function mergeMeta(existing, next) {
+  if (!next) {
+    return existing ? structuredClone(existing) : void 0;
+  }
+  if (!existing) {
+    return structuredClone(next);
+  }
+  return { ...existing, ...clone(next) };
+}
+function isPackageReference(ref) {
+  return ref.includes("/") || ref.startsWith("@");
+}
+function parsePackageReference(ref) {
+  const [pkg, profileId] = ref.split("#");
+  return {
+    packageName: pkg || "",
+    profileId: profileId || "default"
+  };
+}
+async function loadPackageProfile(ref, cwd) {
+  const { packageName, profileId } = parsePackageReference(ref);
+  let pkgJsonPath;
+  try {
+    pkgJsonPath = requireFromHere.resolve(`${packageName}/package.json`, {
+      paths: [cwd]
+    });
+  } catch {
+    throw new KbError(
+      "ERR_PROFILE_EXTENDS_FAILED",
+      `Cannot resolve package "${packageName}" for profile extends`,
+      ERROR_HINTS.ERR_PROFILE_EXTENDS_FAILED,
+      { reference: ref }
+    );
+  }
+  const pkgDir = path3.dirname(pkgJsonPath);
+  const candidateConfigs = [
+    "kb.config.json",
+    "kb.config.yaml",
+    "kb.config.yml",
+    path3.join("config", "kb.config.json"),
+    path3.join("config", "kb.config.yaml"),
+    path3.join("config", "kb.config.yml")
+  ];
+  for (const candidate of candidateConfigs) {
+    const fullPath = path3.join(pkgDir, candidate);
+    try {
+      await promises.access(fullPath);
+    } catch {
+      continue;
+    }
+    const config = await readConfigFile(fullPath);
+    const profiles = config.data?.profiles;
+    const parsed = ProfilesV2Schema.safeParse(profiles);
+    if (!parsed.success) {
+      continue;
+    }
+    const target = parsed.data.find((p) => p.id === profileId);
+    if (!target) {
+      continue;
+    }
+    return {
+      profile: clone(target),
+      source: `npm:${packageName}#${profileId}`,
+      sourcePath: fullPath
+    };
+  }
+  throw new KbError(
+    "ERR_PROFILE_EXTENDS_FAILED",
+    `Profile "${profileId}" not found in package "${packageName}"`,
+    ERROR_HINTS.ERR_PROFILE_EXTENDS_FAILED,
+    { reference: ref }
+  );
+}
+function generateDiffPreview(oldContent, newContent) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const maxLines = 20;
+  const diff = [];
+  for (let i = 0; i < Math.min(maxLines, Math.max(oldLines.length, newLines.length)); i++) {
+    const oldLine = oldLines[i] || "";
+    const newLine = newLines[i] || "";
+    if (oldLine !== newLine) {
+      if (oldLine) {
+        diff.push(`- ${oldLine}`);
+      }
+      if (newLine) {
+        diff.push(`+ ${newLine}`);
+      }
+    }
+  }
+  if (oldLines.length > maxLines || newLines.length > maxLines) {
+    diff.push("... truncated");
+  }
+  return diff.slice(0, 20).join("\n");
+}
+async function findWorkspaceConfig(cwd) {
+  const filenames = [
+    ".kb/kb.config.yaml",
+    ".kb/kb.config.yml",
+    ".kb/kb.config.json"
+  ];
+  const gitRoot = await findGitRoot(cwd);
+  const stopDir = gitRoot || path3.parse(cwd).root;
+  let dir = path3.resolve(cwd);
+  while (true) {
+    for (const filename of filenames) {
+      const candidate = path3.join(dir, filename);
+      try {
+        await promises.access(candidate);
+        const format = filename.endsWith(".json") ? "json" : "yaml";
+        return { path: candidate, format };
+      } catch {
+      }
+    }
+    if (dir === stopDir || dir === path3.dirname(dir)) {
+      break;
+    }
+    dir = path3.dirname(dir);
+  }
+  return null;
+}
+async function initWorkspaceConfig(opts) {
+  const cwd = path3.resolve(opts.cwd);
+  const result = {
+    actions: [],
+    created: [],
+    updated: [],
+    skipped: [],
+    warnings: []
+  };
+  if (opts.profiles && Object.keys(opts.profiles).length > 0) {
+    result.warnings.push(
+      "profiles option is deprecated. Define profiles[] inside kb.config.json (Profiles v2)."
+    );
+  }
+  const existing = await findWorkspaceConfig(cwd);
+  const format = existing?.format || opts.format || "yaml";
+  const configFileName = format === "json" ? "kb.config.json" : "kb.config.yaml";
+  const configPath = existing?.path || path3.join(cwd, ".kb", configFileName);
+  ensureWithinWorkspace(configPath, cwd);
+  const newConfig = {
+    schemaVersion: "1.0",
+    products: {}
+  };
+  if (opts.products && opts.products.length > 0) {
+    for (const product of opts.products) {
+      toFsProduct(product);
+      newConfig.products[product] = {};
+    }
+  }
+  if (opts.presetRef !== void 0) {
+    newConfig.$extends = opts.presetRef;
+  }
+  if (existing) {
+    try {
+      const existingContent = await promises.readFile(existing.path, "utf-8");
+      const existingData = format === "json" ? JSON.parse(existingContent) : YAML2.parse(existingContent);
+      let modified = false;
+      if (!existingData.schemaVersion) {
+        existingData.schemaVersion = "1.0";
+        modified = true;
+      }
+      if (opts.products) {
+        if (!existingData.products) {
+          existingData.products = {};
+          modified = true;
+        }
+        for (const product of opts.products) {
+          if (!existingData.products[product]) {
+            existingData.products[product] = {};
+            modified = true;
+          }
+        }
+      }
+      if (opts.presetRef !== void 0 && existingData.$extends !== opts.presetRef) {
+        existingData.$extends = opts.presetRef;
+        modified = true;
+      }
+      if (!modified) {
+        result.actions.push({ kind: "skip", path: configPath });
+        result.skipped.push(configPath);
+        return result;
+      }
+      const newContent = format === "json" ? JSON.stringify(existingData, null, 2) + "\n" : YAML2.stringify(existingData);
+      if (!opts.force && existingContent !== newContent) {
+        const action = {
+          kind: "conflict",
+          path: configPath,
+          previewDiff: generateDiffPreview(existingContent, newContent)
+        };
+        result.actions.push(action);
+        result.warnings.push(`Config file has changes, use --force to overwrite: ${configPath}`);
+        return result;
+      }
+      if (!opts.dryRun) {
+        await writeFileAtomic(configPath, newContent);
+      }
+      result.actions.push({ kind: "update", path: configPath });
+      result.updated.push(configPath);
+    } catch (error) {
+      throw new KbError(
+        "ERR_CONFIG_INVALID",
+        `Failed to read or parse existing config: ${existing.path}`,
+        ERROR_HINTS.ERR_CONFIG_INVALID,
+        { error: error instanceof Error ? error.message : String(error) }
+      );
+    }
+  } else {
+    const content = format === "json" ? JSON.stringify(newConfig, null, 2) + "\n" : YAML2.stringify(newConfig);
+    if (!opts.dryRun) {
+      await writeFileAtomic(configPath, content);
+    }
+    result.actions.push({ kind: "write", path: configPath });
+    result.created.push(configPath);
+  }
+  return result;
+}
+async function upsertLockfile(opts) {
+  const cwd = path3.resolve(opts.cwd);
+  const lockfilePath = path3.join(cwd, ".kb", "lock.json");
+  const oldLockfilePath = path3.join(cwd, ".kb", "lockfile.json");
+  const result = {
+    actions: [],
+    created: [],
+    updated: [],
+    skipped: [],
+    warnings: []
+  };
+  ensureWithinWorkspace(lockfilePath, cwd);
+  try {
+    await promises.access(oldLockfilePath);
+    result.warnings.push(
+      "Deprecated lockfile found at .kb/lockfile.json, please migrate to .kb/lock.json"
+    );
+  } catch {
+  }
+  const existing = await readLockfile(cwd);
+  const lockfileData = {
+    $schema: "https://schemas.kb-labs.dev/lockfile.schema.json",
+    schemaVersion: "1.0",
+    orgPreset: opts.presetRef !== void 0 ? opts.presetRef || void 0 : existing?.orgPreset,
+    profile: opts.profileRef !== void 0 ? opts.profileRef || void 0 : existing?.profile,
+    policyBundle: opts.policyBundle !== void 0 ? opts.policyBundle || void 0 : existing?.policyBundle,
+    hashes: existing?.hashes || {},
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!existing) {
+    if (!opts.dryRun) {
+      await writeLockfile(cwd, lockfileData);
+    }
+    result.actions.push({ kind: "write", path: lockfilePath });
+    result.created.push(lockfilePath);
+  } else {
+    if (!opts.dryRun) {
+      await writeLockfile(cwd, lockfileData);
+    }
+    result.actions.push({ kind: "update", path: lockfilePath });
+    result.updated.push(lockfilePath);
+  }
+  return result;
+}
+var ajv = new Ajv({ allErrors: true, strict: false });
+addFormats(ajv);
+var schemaMap = {};
+function validateProductConfig(product, config) {
+  const schema = schemaMap[product];
+  if (!schema) {
+    return { ok: true, errors: null };
+  }
+  const validate = ajv.compile(schema);
+  const ok = validate(config);
+  return { ok: !!ok, errors: validate.errors || null };
+}
+
+export { BundleProfileSchema, BundleProfileSourceSchema, FSCache, ProfileMetaSchema, ProfileTraceSchema, ProfileV2Schema, ProfilesV2Schema, ResolvedScopeSchema, SYSTEM_DEFAULTS, ScopeSelectionSchema, ScopeV2Schema, clearCaches, computeConfigHash, computeConfigsHash, explainProductConfig, findGitRoot, findKbConfig, findNearestConfig, fsCache, getAllProductIds, getConfigHash, getKbRootDir, getLockfileConfigHash, getLockfilePath, getLockfileStats, getPresetConfigForProduct, getPresetMetadata, getProductConfig, getProductConfigDir, getProductConfigPath, getProfilesRootDir, initWorkspaceConfig, isLockfileUpToDate, isValidProductId, layeredMergeWithTrace, mergeDefined, pickDefined, readConfigFile, readJsonWithDiagnostics, readKbConfig, readLockfile, readProfilesSection, readWorkspaceConfig, resolveConfig, resolvePreset, resolveProfile, selectProfileScope, toBool, toConfigProduct, toFsProduct, toInt, updateLockfile, upsertLockfile, validateLockfile, validateProductConfig, writeLockfile };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map