@wrongstack/tools 0.310.1 → 0.313.1

package/dist/chunk-6HLZK37X.js

@@ -0,0 +1,359 @@
+import {
+  compileUserRegex
+} from "./chunk-Q5JPPCZC.js";
+import {
+  enqueueReindex
+} from "./chunk-2ME7ZWDD.js";
+import {
+  isBinaryBuffer,
+  safeResolveReal,
+  sha256hex,
+  truncateDiffPayload
+} from "./chunk-D33S4RQG.js";
+
+// src/replace.ts
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { ToolValidationError } from "@wrongstack/core/types";
+import {
+  atomicWrite,
+  buildChildEnv,
+  compileGlob,
+  detectNewlineStyle,
+  expectDefined,
+  normalizeToLf,
+  toStyle,
+  unifiedDiff
+} from "@wrongstack/core/utils";
+var MAX_DIFF_BYTES = 262144;
+var DEFAULT_IGNORE = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+var replaceTool = {
+  name: "replace",
+  category: "Transform",
+  description: "Perform a search-and-replace across multiple files using a regex pattern. This is a powerful bulk transformation tool. Dry-run is ON by default \u2014 set `dry_run: false` to apply changes.",
+  usageHint: "DANGEROUS IF USED CARELESSLY \u2014 review the diff output carefully.\n\nRecommended workflow:\n1. Run without `dry_run: false` first to see exactly what would change (dry-run is the default).\n2. Review the diff output, then re-run with `dry_run: false` to apply.\n3. Use a specific enough `pattern` (and `glob` / `files`) to avoid accidental broad changes.\n4. `replace_all` controls whether only the first match per file or all matches are replaced.\n5. `replacement` supports regex substitutions: `$1`\u2013`$9` insert capture groups, `$&` inserts the whole match, and `$$` inserts a literal dollar sign.\nThis tool is excellent for large-scale refactors (renaming, import updates, etc.) but must be used with caution.",
+  permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The file scope being rewritten, not the pattern: a trust rule should say
+  // where a bulk replace may run.
+  subjectKey: "files",
+  mutating: true,
+  capabilities: ["fs.write"],
+  icon: "edit",
+  timeoutMs: 3e4,
+  maxOutputBytes: 262144,
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Regex pattern to match" },
+      replacement: {
+        type: "string",
+        description: "Replacement string. Supports `$1`\u2013`$9` (capture groups), `$&` (whole match), and `$$` (literal dollar sign) \u2014 same semantics as JavaScript String.replace."
+      },
+      files: {
+        type: "string",
+        description: "File(s) to target: single path, comma-separated list, or glob pattern"
+      },
+      glob: { type: "string", description: 'Additional glob filter (e.g. "*.ts")' },
+      replace_all: {
+        type: "boolean",
+        description: "Replace all occurrences in each file (default: true)"
+      },
+      dry_run: { type: "boolean", description: "Preview changes without writing (default: true)" }
+    },
+    required: ["pattern", "replacement", "files"]
+  },
+  async execute(input, ctx) {
+    if (!input?.pattern) {
+      throw new ToolValidationError({
+        message: "replace: pattern is required",
+        field: "pattern"
+      });
+    }
+    if (input.replacement === void 0) {
+      throw new ToolValidationError({
+        message: "replace: replacement is required",
+        field: "replacement"
+      });
+    }
+    if (!input?.files) {
+      throw new ToolValidationError({
+        message: "replace: files is required",
+        field: "files"
+      });
+    }
+    const replaceAll = input.replace_all ?? true;
+    const compiled = compileUserRegex(input.pattern, "g");
+    if (!compiled.ok) {
+      throw new ToolValidationError({
+        message: `replace: ${compiled.reason}`,
+        field: "pattern"
+      });
+    }
+    const re = compiled.regex;
+    const globRe = input.glob ? compileGlob(input.glob) : null;
+    const dryRun = input.dry_run ?? true;
+    const filesInput = Array.isArray(input.files) ? input.files.join(",") : input.files;
+    const fileList = await resolveFiles(filesInput, ctx, globRe);
+    const realRoot = await fs.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
+    const results = [];
+    let totalReplacements = 0;
+    let diffBytesUsed = 0;
+    let diffsOmitted = 0;
+    let diffsTruncated = 0;
+    for (const absPath of fileList) {
+      const lstat2 = await fs.lstat(absPath).catch((err) => {
+        if (err.code === "ENOENT") return null;
+        throw err;
+      });
+      if (!lstat2?.isFile()) continue;
+      if (lstat2.isSymbolicLink()) continue;
+      let realPath;
+      try {
+        realPath = await fs.realpath(absPath);
+      } catch {
+        continue;
+      }
+      const rel = path.relative(realRoot, realPath);
+      if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
+      const stat2 = await fs.stat(realPath).catch(() => null);
+      if (!stat2?.isFile()) continue;
+      let content;
+      try {
+        const buf = await fs.readFile(realPath);
+        if (isBinaryBuffer(buf)) continue;
+        content = buf.toString("utf8");
+      } catch {
+        continue;
+      }
+      const style = detectNewlineStyle(content);
+      const contentLf = normalizeToLf(content);
+      re.lastIndex = 0;
+      const allMatches = [...contentLf.matchAll(re)];
+      if (allMatches.length === 0) continue;
+      const matches = replaceAll ? allMatches : allMatches.slice(0, 1);
+      const count = matches.length;
+      let newContentLf = contentLf;
+      for (let i = matches.length - 1; i >= 0; i--) {
+        const m = expectDefined(matches[i]);
+        newContentLf = newContentLf.slice(0, m.index) + expandReplacement(input.replacement, m) + newContentLf.slice(expectDefined(m.index) + m[0].length);
+      }
+      re.lastIndex = 0;
+      totalReplacements += count;
+      if (!dryRun) {
+        const newContent = toStyle(newContentLf, style);
+        await atomicWrite(realPath, newContent, { mode: stat2.mode & 511 });
+        const written = await fs.stat(realPath).catch(() => null);
+        if (written) {
+          ctx.recordRead?.(realPath, written.mtimeMs, "write", sha256hex(newContent));
+        }
+        ctx.session?.recordFileChange?.({
+          path: realPath,
+          action: "modified",
+          before: content,
+          after: newContent
+        });
+      }
+      let diff = dryRun || matches.length > 0 ? unifiedDiff(content, toStyle(newContentLf, style), {
+        fromFile: absPath,
+        toFile: absPath
+      }) : void 0;
+      if (diff !== void 0) {
+        const remaining = MAX_DIFF_BYTES - diffBytesUsed;
+        if (remaining <= 0) {
+          diff = void 0;
+          diffsOmitted++;
+        } else {
+          const capped = truncateDiffPayload(diff, remaining);
+          if (capped.truncated) diffsTruncated++;
+          diff = capped.text;
+          diffBytesUsed += Buffer.byteLength(diff, "utf8");
+        }
+      }
+      results.push({
+        path: absPath,
+        replacements: matches.length,
+        diff
+      });
+    }
+    if (!dryRun && results.length > 0) {
+      try {
+        enqueueReindex({
+          projectRoot: ctx.projectRoot,
+          files: results.map((r) => r.path)
+        });
+      } catch {
+      }
+    }
+    const overBudget = diffsOmitted > 0 || diffsTruncated > 0;
+    return {
+      files_modified: results.length,
+      total_replacements: totalReplacements,
+      results,
+      dry_run: dryRun,
+      note: overBudget ? `Diff payload exceeded the 256 KiB output budget: ${diffsTruncated} diff(s) truncated, ${diffsOmitted} diff(s) omitted. Replacement counts are complete; use the read tool to inspect individual files.` : void 0
+    };
+  }
+};
+function expandReplacement(template, match) {
+  if (!template.includes("$")) return template;
+  let out = "";
+  for (let i = 0; i < template.length; i++) {
+    const ch = template[i];
+    if (ch !== "$") {
+      out += ch;
+      continue;
+    }
+    const next = template[i + 1];
+    if (next === "$") {
+      out += "$";
+      i++;
+    } else if (next === "&") {
+      out += match[0];
+      i++;
+    } else if (next !== void 0 && next >= "1" && next <= "9") {
+      const idx = next.charCodeAt(0) - 48;
+      if (idx < match.length) {
+        out += match[idx] ?? "";
+        i++;
+      } else {
+        out += "$";
+      }
+    } else {
+      out += "$";
+    }
+  }
+  return out;
+}
+function passesExtraGlob(extraGlob, name, full) {
+  extraGlob.lastIndex = 0;
+  const nameMatch = extraGlob.test(name);
+  extraGlob.lastIndex = 0;
+  const fullMatch = extraGlob.test(full);
+  extraGlob.lastIndex = 0;
+  return nameMatch || fullMatch;
+}
+async function resolveFiles(filesInput, ctx, extraGlob) {
+  const base = ctx.cwd;
+  const normalized = filesInput.trim();
+  if (normalized.startsWith("**/") || normalized.startsWith("*") || normalized.includes("**")) {
+    return await globFiles(normalized, base, extraGlob);
+  }
+  const parts = normalized.split(",").map((s) => s.trim()).filter(Boolean);
+  const resolved = [];
+  for (const p of parts) {
+    const absPath = await safeResolveReal(p, ctx);
+    if (extraGlob && !passesExtraGlob(extraGlob, path.basename(absPath), absPath)) continue;
+    const stat2 = await fs.stat(absPath).catch(() => null);
+    if (stat2?.isFile()) {
+      resolved.push(absPath);
+    }
+  }
+  return resolved;
+}
+async function globFiles(pattern, base, extraGlob) {
+  const rgAvailable = await checkRg();
+  if (rgAvailable) {
+    try {
+      const { promise } = spawnRgFind(pattern, base);
+      const files = await promise;
+      if (extraGlob) {
+        return files.filter((f) => passesExtraGlob(extraGlob, path.basename(f), f));
+      }
+      return files;
+    } catch {
+    }
+  }
+  return await globNative(pattern, base, extraGlob);
+}
+var rgAvailabilityCache;
+function __resetRgDetectionForTests() {
+  rgAvailabilityCache = void 0;
+}
+function checkRg() {
+  rgAvailabilityCache ??= new Promise((resolve) => {
+    try {
+      const p = spawn("rg", ["--version"], {
+        env: buildChildEnv(),
+        stdio: "ignore",
+        windowsHide: true
+      });
+      p.on("error", () => resolve(false));
+      p.on("close", (code) => resolve(code === 0));
+    } catch {
+      resolve(false);
+    }
+  });
+  return rgAvailabilityCache;
+}
+function spawnRgFind(pattern, base) {
+  const args = ["--files", "--glob", pattern, base];
+  const child = spawn("rg", args, {
+    signal: AbortSignal.timeout(3e4),
+    env: buildChildEnv(),
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  const MAX_BUF_CHARS = 8 * 1024 * 1024;
+  let buf = "";
+  let truncated = false;
+  child.stdout?.on("data", (chunk) => {
+    if (truncated) return;
+    buf += chunk.toString();
+    if (buf.length > MAX_BUF_CHARS) {
+      truncated = true;
+      buf = buf.slice(0, buf.lastIndexOf("\n") + 1);
+      child.kill();
+    }
+  });
+  return {
+    promise: new Promise((resolve, reject) => {
+      child.on("error", reject);
+      child.on("close", () => {
+        resolve(buf.split("\n").filter(Boolean));
+      });
+    })
+  };
+}
+async function globNative(pattern, base, extraGlob) {
+  const results = [];
+  const globRe = compileGlob(pattern);
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (DEFAULT_IGNORE.includes(e.name)) continue;
+      const full = path.join(dir, e.name);
+      try {
+        const stat2 = await fs.lstat(full);
+        if (stat2.isSymbolicLink()) continue;
+      } catch {
+        continue;
+      }
+      if (e.isDirectory()) {
+        await walk(full);
+      } else if (e.isFile()) {
+        const name = e.name;
+        if (globRe.test(name) || globRe.test(full)) {
+          if (extraGlob && !extraGlob.test(name) && !extraGlob.test(full)) continue;
+          results.push(full);
+        }
+        globRe.lastIndex = 0;
+        if (extraGlob) extraGlob.lastIndex = 0;
+      }
+    }
+  };
+  await walk(base);
+  return results;
+}
+
+export {
+  replaceTool,
+  __resetRgDetectionForTests
+};
+//# sourceMappingURL=chunk-6HLZK37X.js.map

package/dist/chunk-6RNIFLG4.js

@@ -0,0 +1,305 @@
+// src/design.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  applyTokenOverrides,
+  getDesignKitLoader,
+  isDesignStack,
+  loadActiveKit,
+  materializeTokens,
+  recordKitChoice,
+  recordOverrides,
+  resolveSemanticTune,
+  runDesignVerify,
+  setActiveKit,
+  setDesignOverrides
+} from "@wrongstack/core/design";
+async function resolveReal(p) {
+  const resolved = path.resolve(p);
+  let probe = resolved;
+  const missing = [];
+  for (; ; ) {
+    try {
+      return path.resolve(await fs.realpath(probe), ...missing);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        const parent = path.dirname(probe);
+        if (parent === probe) return resolved;
+        missing.unshift(path.basename(probe));
+        probe = parent;
+        continue;
+      }
+      return resolved;
+    }
+  }
+}
+function normalizeOverrides(set) {
+  const out = {};
+  if (set && typeof set === "object") {
+    for (const [k, v] of Object.entries(set)) {
+      if (typeof v === "string") out[k] = v;
+    }
+  }
+  return out;
+}
+var designTool = {
+  name: "design",
+  category: "Design",
+  description: 'Browse, load, customize, and enforce curated frontend/mobile UI design kits. Use BEFORE writing UI code to commit to one coherent, modern, responsive, dark/light, accessible design. Actions: "list" (menu), "use" (load+pin a kit for a stack), "foundations" (baseline), "set" (override kit colors/tokens), "materialize" (write the tokens to a real theme file \u2014 CSS @theme/OKLCH or native), "verify" (scan UI files for off-palette colors).',
+  usageHint: 'Flow: `design {action:"use", kit:"minimal-clarity", stack:"web"}` \u2192 optionally `design {action:"set", set:{primary:"oklch(62% 0.2 25)"}}` \u2192 `design {action:"materialize"}` to write tokens to disk \u2192 implement against them \u2192 `design {action:"verify"}`.',
+  permission: "confirm",
+  // WS-046: gives permission decisions something to key on.
+  // The action performed; `out` is optional so it cannot be the subject.
+  subjectKey: "action",
+  mutating: true,
+  capabilities: ["fs.write"],
+  timeoutMs: 15e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      action: {
+        type: "string",
+        enum: ["list", "use", "foundations", "set", "tune", "materialize", "verify"],
+        description: "list = menu; use = load+pin a kit; foundations = baseline; set = override colors/tokens; tune = high-level knobs (radius/density/font/motion); materialize = write tokens to a theme file; verify = scan UI for token drift. Default: list."
+      },
+      kit: {
+        type: "string",
+        description: 'Kit id (required for "use"), e.g. "minimal-clarity", "neo-brutalist".'
+      },
+      stack: {
+        type: "string",
+        enum: ["web", "react-native", "flutter", "swiftui", "compose"],
+        description: "Target stack \u2014 narrows guidance + materialize format. Default: web."
+      },
+      set: {
+        type: "object",
+        description: 'Token overrides for "set"/"use": { "primary": "oklch(\u2026)", "dark.bg": "#111" }. Bare key = both themes; "light."/"dark." prefix = that theme only. Empty value clears an override.',
+        additionalProperties: { type: "string" }
+      },
+      tune: {
+        type: "object",
+        description: 'High-level knobs for "tune": { "radius": "lg", "density": "compact", "font": "Space Grotesk", "motion": "snappy" }. radius = none|sm|md|lg|xl|full or a base length; density = compact|cozy|comfortable; motion = snappy|smooth|none. Resolved to concrete token overrides.',
+        properties: {
+          radius: { type: "string" },
+          density: { type: "string" },
+          font: { type: "string" },
+          motion: { type: "string" }
+        }
+      },
+      out: {
+        type: "string",
+        description: "Materialize output path (project-relative). Defaults to a per-stack convention."
+      },
+      force: {
+        type: "boolean",
+        description: "Materialize: overwrite an existing file (default false \u2014 refuses to clobber)."
+      },
+      files: {
+        type: "array",
+        items: { type: "string" },
+        description: "Verify: explicit project-relative files to scan. Default: a bounded UI-file walk."
+      }
+    },
+    required: []
+  },
+  async execute(input, ctx) {
+    const loader = getDesignKitLoader(ctx.projectRoot);
+    const action = input.action ?? "list";
+    const stack = input.stack && isDesignStack(input.stack) ? input.stack : void 0;
+    if (action === "foundations") {
+      const text = await loader.foundationsText(stack);
+      return { action, stack, output: text || "No foundations document is installed." };
+    }
+    if (action === "use") {
+      const kitId = input.kit?.trim();
+      if (!kitId) {
+        const menu2 = await loader.menuText();
+        return { action, output: `No kit id provided.
+
+${menu2}` };
+      }
+      const manifest = await loader.find(kitId);
+      if (!manifest) {
+        const menu2 = await loader.menuText();
+        return { action, kit: kitId, output: `Kit "${kitId}" not found.
+
+${menu2}` };
+      }
+      const resolvedStack = stack ?? manifest.stacks[0] ?? "web";
+      const body = await loader.readBody(manifest.id, resolvedStack);
+      const rawTokens = await loader.readTokens(manifest.id);
+      const persisted = await loadActiveKit(ctx.projectRoot);
+      const keepOverrides = persisted?.kit === manifest.id ? persisted.overrides ?? {} : {};
+      const overrides = { ...keepOverrides, ...normalizeOverrides(input.set) };
+      const tokens = rawTokens ? applyTokenOverrides(rawTokens, overrides) : rawTokens;
+      setActiveKit(ctx, manifest.id, resolvedStack, overrides);
+      await recordKitChoice(
+        ctx.projectRoot,
+        manifest.id,
+        resolvedStack,
+        "design-tool",
+        (/* @__PURE__ */ new Date()).toISOString(),
+        Object.keys(overrides).length ? overrides : void 0
+      );
+      const ovLine = Object.keys(overrides).length ? `
+Active color overrides: ${Object.entries(overrides).map(([k, v]) => `${k}=${v}`).join(", ")}
+` : "";
+      const header = `# Active design kit: ${manifest.name} (${manifest.id}) \u2014 stack: ${resolvedStack}
+${manifest.aesthetic}
+${ovLine}
+Implement the UI faithfully to this spec. Keep light/dark, responsive, and WCAG AA.
+`;
+      const tokenBlock = tokens ? `
+## Token snapshot (overrides applied)
+\`\`\`json
+${JSON.stringify(tokens, null, 2)}
+\`\`\`
+Tip: run \`design {action:"materialize"}\` to write these tokens to a real theme file.
+` : "";
+      return {
+        action,
+        kit: manifest.id,
+        stack: resolvedStack,
+        output: `${header}${tokenBlock}
+${body}`
+      };
+    }
+    if (action === "set") {
+      const patch = normalizeOverrides(input.set);
+      if (Object.keys(patch).length === 0) {
+        return { action, output: 'No overrides given. Pass set:{ "primary": "oklch(\u2026)" }.' };
+      }
+      const merged = await recordOverrides(ctx.projectRoot, patch, (/* @__PURE__ */ new Date()).toISOString());
+      if (!merged) {
+        return {
+          action,
+          output: 'No active kit. Pick one first: `design {action:"use", kit:"<id>"}`.'
+        };
+      }
+      setDesignOverrides(ctx, merged);
+      return {
+        action,
+        output: `Overrides updated. Active overrides: ${Object.entries(merged).map(([k, v]) => `${k}=${v}`).join(", ")}
+These win over kit tokens. Run \`design {action:"materialize"}\` to write them to a theme file.`
+      };
+    }
+    if (action === "tune") {
+      const patch = resolveSemanticTune(input.tune ?? {});
+      if (Object.keys(patch).length === 0) {
+        return {
+          action,
+          output: 'No recognized knobs. Pass tune:{ radius:"lg", density:"compact", font:"\u2026", motion:"snappy" }.'
+        };
+      }
+      const merged = await recordOverrides(ctx.projectRoot, patch, (/* @__PURE__ */ new Date()).toISOString());
+      if (!merged) {
+        return {
+          action,
+          output: 'No active kit. Pick one first: `design {action:"use", kit:"<id>"}`.'
+        };
+      }
+      setDesignOverrides(ctx, merged);
+      return {
+        action,
+        output: `Tuned. Resolved ${Object.keys(patch).length} token override(s): ${Object.entries(patch).map(([k, v]) => `${k}=${v}`).join(", ")}
+Run \`design {action:"materialize"}\` to write the tuned tokens to your theme file.`
+      };
+    }
+    if (action === "materialize") {
+      const active = await loadActiveKit(ctx.projectRoot);
+      if (!active) {
+        return {
+          action,
+          output: 'No active kit. Pick one first: `design {action:"use", kit:"<id>"}`.'
+        };
+      }
+      const resolvedStack = stack ?? (active.stack && isDesignStack(active.stack) ? active.stack : "web");
+      const rawTokens = await loader.readTokens(active.kit);
+      if (!rawTokens) {
+        return { action, kit: active.kit, output: `Kit "${active.kit}" has no tokens.json.` };
+      }
+      const tokens = applyTokenOverrides(rawTokens, active.overrides);
+      const result = materializeTokens({
+        tokens,
+        stack: resolvedStack,
+        kitId: active.kit,
+        outPath: input.out
+      });
+      const root = await resolveReal(ctx.projectRoot);
+      const absResolved = path.isAbsolute(result.path) ? path.resolve(result.path) : path.resolve(path.join(ctx.projectRoot, result.path));
+      const absParent = await resolveReal(path.dirname(absResolved));
+      const abs = path.join(absParent, path.basename(absResolved));
+      const rel = path.relative(root, abs);
+      if (rel.startsWith("..") || path.isAbsolute(rel)) {
+        throw new Error(`design: materialize path "${result.path}" would escape the project root`);
+      }
+      let exists = false;
+      try {
+        await fs.access(abs);
+        exists = true;
+      } catch {
+      }
+      if (exists && !input.force) {
+        return {
+          action,
+          kit: active.kit,
+          stack: resolvedStack,
+          path: result.path,
+          output: `${result.path} already exists. Re-run with force:true to overwrite, or write this ${result.format} yourself:
+
+\`\`\`
+${result.content}
+\`\`\``
+        };
+      }
+      await fs.mkdir(path.dirname(abs), { recursive: true });
+      await fs.writeFile(abs, result.content);
+      return {
+        action,
+        kit: active.kit,
+        stack: resolvedStack,
+        path: result.path,
+        output: `Wrote ${result.format} to ${result.path}. Import these tokens in your UI so the kit palette is the source of truth. ${exists ? "(overwrote existing file)" : ""}`
+      };
+    }
+    if (action === "verify") {
+      const active = await loadActiveKit(ctx.projectRoot);
+      if (!active) {
+        return {
+          action,
+          output: 'No active kit to verify against. Pick one: `design {action:"use", kit:"<id>"}`.'
+        };
+      }
+      const rawTokens = await loader.readTokens(active.kit);
+      if (!rawTokens) {
+        return { action, kit: active.kit, output: `Kit "${active.kit}" has no tokens.json.` };
+      }
+      const tokens = applyTokenOverrides(rawTokens, active.overrides);
+      const report = await runDesignVerify(ctx.projectRoot, tokens, input.files);
+      const pct = Math.round(report.score * 100);
+      const top = report.violations.slice(0, 25).map((v) => `  ${v.file}:${v.line} \u2014 ${v.reason}: ${v.snippet}`).join("\n");
+      const summary = `Adherence: ${pct}% on-palette across ${report.filesScanned} file(s). ${report.violations.length} violation(s).` + (report.violations.length ? `
+${top}${report.violations.length > 25 ? `
+  \u2026and ${report.violations.length - 25} more` : ""}
+
+Replace off-palette colors with kit tokens (or the materialized CSS vars / token utilities).` : "\nNo off-palette colors found \u2014 UI adheres to the kit palette.");
+      return {
+        action,
+        kit: active.kit,
+        output: summary,
+        score: report.score,
+        violations: report.violations.length
+      };
+    }
+    const menu = await loader.menuText();
+    return {
+      action: "list",
+      output: (menu || "No design kits are installed.") + '\n\nLoad one with `design {action:"use", kit:"<id>", stack:"<stack>"}`.'
+    };
+  }
+};
+
+export {
+  designTool
+};
+//# sourceMappingURL=chunk-6RNIFLG4.js.map