@ahnseungchan/device-farm 0.0.0-stage → 0.1.1

package/dist/chunk-SWW42KTA.js

@@ -0,0 +1,223 @@
+import {
+  samePath,
+  sleep
+} from "./chunk-NLX3V7ZJ.js";
+
+// packages/core/src/flows/schema.ts
+var idPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var prdPattern = /^[A-Za-z0-9._()[\]/-]+\.md$/;
+var stepLabels = { home: "\uD648\uC5D0\uC11C \uC2DC\uC791", click: "\uB204\uB974\uAE30", expectText: "\uBB38\uAD6C \uD655\uC778" };
+function stepTarget(step, homeTabName = "\uD648") {
+  if (step.type === "home") return homeTabName;
+  if (step.type === "click") return step.target.match === "prefix" ? `${step.target.name}\u2026` : step.target.name;
+  return step.text;
+}
+function isPrdName(name) {
+  return prdPattern.test(name) && !name.split("/").some((part) => part === ".." || part === "" || part === ".");
+}
+function failed(id, name, prd, requirement, reason) {
+  return { id, name, source: "ai_generated", status: "generation_failed", prd, requirement, reason, steps: [] };
+}
+function stepOf(raw, forbiddenClickNames) {
+  if (!raw || typeof raw !== "object") return "\uC2A4\uD15D \uD615\uC2DD\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.";
+  const step = raw;
+  if (step.type === "home") return { type: "home" };
+  if (step.type === "navigate") return "\uD50C\uB85C\uC6B0\uB294 \uD648\uC5D0\uC11C \uBC84\uD2BC\xB7\uB9C1\uD06C\uB85C\uB9CC \uC774\uB3D9\uD569\uB2C8\uB2E4. navigate\uB294 \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  if (step.type === "click") {
+    const role = step.target?.role;
+    if (role !== "button" && role !== "link" || typeof step.target?.name !== "string" || !step.target.name) {
+      return "\uBC84\uD2BC\xB7\uB9C1\uD06C \uC774\uB984\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.";
+    }
+    if (forbiddenClickNames.includes(step.target.name)) {
+      return `\u300C${step.target.name}\u300D \uBC84\uD2BC\uC740 \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4(\uAE08\uC9C0 \uBC84\uD2BC).`;
+    }
+    if (step.target.match !== void 0 && step.target.match !== "prefix") return "match\uB294 prefix\uB9CC \uC4F8 \uC218 \uC788\uC2B5\uB2C8\uB2E4.";
+    return { type: "click", target: { role, name: step.target.name, ...step.target.match === "prefix" ? { match: "prefix" } : {} } };
+  }
+  if (step.type === "expectText") {
+    if (typeof step.text !== "string" || !step.text) return "\uAE30\uB300 \uBB38\uAD6C\uAC00 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4.";
+    return { type: "expectText", text: step.text };
+  }
+  return "\uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uB3D9\uC791\uC785\uB2C8\uB2E4.";
+}
+function proposalError(proposal, id, readyIds) {
+  if (proposal !== "keep" && proposal !== "update" && proposal !== "create" && proposal !== "delete") return "proposal\uC774 \uC62C\uBC14\uB974\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.";
+  if (proposal !== "create" && !readyIds.has(id)) return "\uD655\uC815\uB41C \uC2DC\uB098\uB9AC\uC624\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  if (proposal === "create" && readyIds.has(id)) return "\uC774\uBBF8 \uD655\uC815\uB41C \uC2DC\uB098\uB9AC\uC624\uC785\uB2C8\uB2E4.";
+  return null;
+}
+function stepsOf(raw, forbiddenClickNames) {
+  if (!Array.isArray(raw) || raw.length === 0) return "\uC2A4\uD15D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  const steps = [];
+  for (const entry of raw) {
+    const step = stepOf(entry, forbiddenClickNames);
+    if (typeof step === "string") return step;
+    steps.push(step);
+  }
+  if (!steps.some((step) => step.type === "click")) return "\uB204\uB974\uB294 \uC2A4\uD15D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  if (!steps.some((step) => step.type === "expectText")) return "\uAE30\uB300 \uBB38\uAD6C\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  return steps;
+}
+function validateGenerated(raw, index, readyIds, prd, prdBody, forbiddenClickNames) {
+  const record = raw && typeof raw === "object" ? raw : {};
+  const id = typeof record.id === "string" && idPattern.test(record.id) ? record.id : `invalid-${index + 1}`;
+  const name = typeof record.name === "string" && record.name ? record.name : "\uC774\uB984 \uC5C6\uB294 \uD50C\uB85C\uC6B0";
+  const requirement = typeof record.requirement === "string" ? record.requirement : "";
+  if (!requirement || !prdBody.includes(requirement)) return failed(id, name, prd, requirement || "\uC694\uAD6C \uBB38\uC7A5", "\uC694\uAD6C \uBB38\uC7A5\uC774 PRD\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  const proposal = record.proposal;
+  const wrongProposal = proposalError(proposal, id, readyIds);
+  if (wrongProposal) return failed(id, name, prd, requirement, wrongProposal);
+  const steps = stepsOf(record.steps, forbiddenClickNames);
+  if (typeof steps === "string") return failed(id, name, prd, requirement, steps);
+  return { id, name, source: "ai_generated", status: "generated", prd, requirement, proposal, steps };
+}
+
+// packages/core/src/explore/actions.ts
+var domHelpers = `
+  const nameOf = (el) => (el.getAttribute("aria-label") || el.innerText || el.value || el.title || el.getAttribute("alt") || "").replace(/\\s+/g, " ").trim();
+  const isVisible = (el) => {
+    const rect = el.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0) return false;
+    const style = getComputedStyle(el);
+    return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
+  };
+  const isEnabled = (el) => !el.disabled && el.getAttribute("aria-disabled") !== "true" && !el.closest("[inert]");
+  const isUsable = (el) => isVisible(el) && isEnabled(el);
+  const buttons = () => Array.from(document.querySelectorAll('button, [role="button"], input[type="button"], input[type="submit"]')).filter(isUsable);
+  const isSafeLink = (el) => {
+    if (el.getAttribute("target") === "_blank") return false;
+    if (!el.href) return true;
+    return el.href.startsWith("http://") || el.href.startsWith("https://");
+  };
+  const links = () => Array.from(document.querySelectorAll('a[href], [role="link"]')).filter((el) => isUsable(el) && isSafeLink(el));
+  const skippedInputTypes = ["hidden", "password", "file", "checkbox", "radio", "submit", "button", "image", "reset"];
+  const labelOf = (el) => (el.getAttribute("aria-label") || (el.labels && el.labels[0] ? el.labels[0].innerText : "") || el.getAttribute("placeholder") || "").replace(/\\s+/g, " ").trim();
+  const inputs = () => Array.from(document.querySelectorAll("input, textarea")).filter((el) => isUsable(el) && !el.readOnly && !skippedInputTypes.includes((el.getAttribute("type") || "").toLowerCase()));
+`;
+var listActionsScript = `(() => {${domHelpers}
+  return [
+    ...buttons().map((el) => ({ role: "button", name: nameOf(el) })),
+    ...links().map((el) => ({ role: "link", name: nameOf(el) })),
+    ...inputs().map((el) => ({ role: "input", name: labelOf(el) })),
+  ].filter((item) => item.name.length > 0);
+})()`;
+function linkClickScript(name) {
+  return `(() => {${domHelpers}
+  const target = links().find((el) => nameOf(el) === ${JSON.stringify(name)});
+  if (!target) throw new Error("\uB9C1\uD06C \uC5C6\uC74C: " + ${JSON.stringify(name)});
+  target.click();
+  return true;
+})()`;
+}
+function fillScript(label, value) {
+  return `(() => {${domHelpers}
+  const target = inputs().find((el) => labelOf(el) === ${JSON.stringify(label)});
+  if (!target) throw new Error("\uC785\uB825\uCE78 \uC5C6\uC74C: " + ${JSON.stringify(label)});
+  const proto = target instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+  Object.getOwnPropertyDescriptor(proto, "value").set.call(target, ${JSON.stringify(value)});
+  target.dispatchEvent(new Event("input", { bubbles: true }));
+  target.dispatchEvent(new Event("change", { bubbles: true }));
+  return true;
+})()`;
+}
+function hasForbiddenWord(name, words) {
+  const compact = name.replace(/\s+/g, "");
+  return words.some((word) => compact.includes(word.replace(/\s+/g, "")));
+}
+
+// packages/core/src/device/button-check.ts
+var buttonCheckLimits = { maxButtonsPerScreen: 12, settleMs: 1500, maxTexts: 5 };
+var buttonErrorKinds = ["app-error", "crash", "network", "login-redirect"];
+function skippedButtonNames(app) {
+  return [...app.inPageBackNames, ...Object.keys(app.tabPaths)];
+}
+var fingerprintScript = `(() => {
+  const text = (document.body ? document.body.innerText : "").replace(/\\s+/g, " ").trim();
+  const dialogs = document.querySelectorAll('[role="dialog"], [aria-modal="true"]').length;
+  return text.length + "|" + dialogs + "|" + text.slice(0, 200) + "|" + text.slice(-200);
+})()`;
+async function fingerprint(driver) {
+  return { path: await driver.currentPath(), content: await driver.evaluate(fingerprintScript) };
+}
+var screenTextsScript = `(() => {
+  const dialogs = Array.from(document.querySelectorAll('[role="dialog"], [aria-modal="true"]'));
+  const root = dialogs.at(-1) || document;
+  const visible = (el) => { const rect = el.getBoundingClientRect(); return rect.width > 0 && rect.height > 0; };
+  const nodes = Array.from(root.querySelectorAll('h1, h2, h3, [role="heading"], header p, [role="dialog"] p')).filter(visible);
+  const texts = nodes.map((el) => el.innerText.replace(/\\s+/g, " ").trim()).filter((text) => text.length > 0 && text.length <= 40);
+  return [...new Set(texts)].slice(0, ${buttonCheckLimits.maxTexts});
+})()`;
+function reaction(before, after) {
+  if (before.path !== after.path) return `${after.path}\uB85C \uC774\uB3D9`;
+  if (before.content !== after.content) return "\uD654\uBA74 \uB0B4\uC6A9 \uBC14\uB01C";
+  return null;
+}
+async function listButtons(driver, max = buttonCheckLimits.maxButtonsPerScreen) {
+  const candidates = await driver.evaluate(listActionsScript);
+  const unique = /* @__PURE__ */ new Map();
+  const skipped = skippedButtonNames(driver.app);
+  for (const { role, name } of candidates) {
+    if (role === "input" || hasForbiddenWord(name, driver.app.guard.forbiddenButtonWords) || skipped.includes(name)) continue;
+    unique.set(`${role}:${name}`, { role, name });
+  }
+  return [...unique.values()].slice(0, max);
+}
+async function pressOne(driver, target, deps) {
+  const now = deps.now ?? Date.now;
+  const before = await fingerprint(driver);
+  const since = now();
+  try {
+    await driver.clickButton(target.name, target.role);
+  } catch (error) {
+    return { ...target, status: "skipped", message: error instanceof Error ? error.message : String(error) };
+  }
+  await sleep(deps.settleMs ?? buttonCheckLimits.settleMs);
+  const errors = (await deps.probe(since)).filter((issue) => buttonErrorKinds.includes(issue.kind));
+  const after = await fingerprint(driver).catch(() => ({ path: "", content: "" }));
+  const changed = reaction(before, after);
+  const texts = changed ? await driver.evaluate(screenTextsScript).catch(() => []) : [];
+  if (changed) await deps.restore();
+  if (errors.length > 0) return { ...target, status: "error", message: errors.map((issue) => issue.message).join(" \xB7 ") };
+  if (!changed) return { ...target, status: "dead" };
+  return { ...target, status: "reacted", message: changed, texts, ...before.path !== after.path ? { to: after.path } : {} };
+}
+async function checkButtons(driver, deps) {
+  const results = [];
+  const targets = await listButtons(driver, deps.maxButtons);
+  for (const [index, target] of targets.entries()) {
+    results.push(await pressOne(driver, target, deps));
+    const path = await driver.currentPath().catch(() => "");
+    if (!samePath(deps.screenPath, path)) {
+      const rest = targets.slice(index + 1).map((skipped) => ({ ...skipped, status: "skipped", message: `\uD654\uBA74 \uBCF5\uADC0 \uC2E4\uD328: ${path}\uC5D0 \uBA38\uBB3E` }));
+      return [...results, ...rest];
+    }
+  }
+  return results;
+}
+function summarizeButtons(results) {
+  const named = (status) => results.filter((item) => item.status === status).map((item) => item.name);
+  const dead = named("dead");
+  const errors = named("error");
+  const skipped = named("skipped");
+  const parts = [`\uBC84\uD2BC ${results.length}\uAC1C`];
+  if (dead.length > 0) parts.push(`\uBC18\uC751 \uC5C6\uC74C ${dead.length}(${dead.join(", ")})`);
+  if (errors.length > 0) parts.push(`\uC5D0\uB7EC ${errors.length}(${errors.join(", ")})`);
+  if (skipped.length > 0) parts.push(`\uAC74\uB108\uB700 ${skipped.length}`);
+  return parts.join(" \xB7 ");
+}
+
+export {
+  listActionsScript,
+  linkClickScript,
+  fillScript,
+  hasForbiddenWord,
+  buttonCheckLimits,
+  screenTextsScript,
+  checkButtons,
+  summarizeButtons,
+  stepLabels,
+  stepTarget,
+  isPrdName,
+  stepsOf,
+  validateGenerated
+};

package/dist/chunk-UAHWEUDI.js

@@ -0,0 +1,68 @@
+import {
+  classifyWithFigma,
+  findingLabels,
+  screenMatches,
+  shortHash,
+  squash
+} from "./chunk-F6PZOBU6.js";
+
+// packages/core/src/policy/compare.ts
+var isIgnored = (ignores, key, hash) => ignores.some((item) => item.key === key && item.hash === hash);
+var rulesForScreen = (rules, path) => rules.filter((rule) => rule.screens.some((pattern) => screenMatches(pattern, path)));
+var screenTextHash = (text) => shortHash(squash(text).replace(/\d[\d,.:]*/g, "#"));
+var inFigma = (figmaTexts, expected) => figmaTexts && figmaTexts.length > 0 ? figmaTexts.map(squash).join("\0").includes(squash(expected)) : null;
+var failed = (rule, message, context) => {
+  const figma = inFigma(context.figmaTexts, rule.expected ?? "");
+  const finding = classifyWithFigma(rule, figma, context.screenChanged, context.now);
+  const side = figma === null ? "" : figma ? " \uD53C\uADF8\uB9C8\uC5D0\uB294 \uC788\uC2B5\uB2C8\uB2E4." : " \uD53C\uADF8\uB9C8\uC5D0\uB3C4 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  message = `${message}${side}`;
+  const ignored = isIgnored(context.ignores, rule.id, rule.pageHash);
+  return { id: rule.id, title: rule.statement, ok: false, message: `[${findingLabels[finding]}] ${message} \xB7 \u300C${rule.pageTitle}\u300D`, finding, ignoreKey: rule.id, ignoreHash: rule.pageHash, ignored, pageId: rule.pageId };
+};
+function compareCopyRules(rules, context) {
+  const screenText = squash(context.text);
+  return rulesForScreen(rules, context.path).filter((rule) => rule.kind !== "behavior" && rule.visibleOnOpen && rule.expected).map(
+    (rule) => screenText.includes(squash(rule.expected ?? "")) ? { id: rule.id, title: rule.statement, ok: true, ignoreKey: rule.id, ignoreHash: rule.pageHash, pageId: rule.pageId } : failed(rule, `\uD654\uBA74\uC5D0 \u300C${rule.expected}\u300D\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.`, context)
+  );
+}
+var situationalRules = (rules, path) => rulesForScreen(rules, path).filter((rule) => rule.kind !== "behavior" && !rule.visibleOnOpen);
+var maxCopyDiff = 30;
+var minCopyLength = 2;
+var isStaticCopy = (text) => squash(text).length >= minCopyLength && !/\d/.test(text);
+function diffFigmaCopy(figmaTexts, screenText) {
+  const screen = squash(screenText);
+  const figma = figmaTexts.map(squash).join("\0");
+  const missingOnScreen = [...new Set(figmaTexts.map((text) => text.trim()).filter((text) => isStaticCopy(text) && !screen.includes(squash(text))))];
+  const notInFigma = [...new Set(screenText.split("\n").map((line) => line.trim()).filter((line) => isStaticCopy(line) && !figma.includes(squash(line))))];
+  return { missingOnScreen: missingOnScreen.slice(0, maxCopyDiff), notInFigma: notInFigma.slice(0, maxCopyDiff) };
+}
+function figmaChecks(diff, figmaHash, path, ignores) {
+  const toCheck = (text, side) => {
+    const key = `figma:${path}:${side}:${squash(text)}`;
+    const message = side === "missing" ? "\uD53C\uADF8\uB9C8\uC5D0 \uC788\uB294\uB370 \uD654\uBA74\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4." : "\uD654\uBA74\uC5D0 \uC788\uB294\uB370 \uD53C\uADF8\uB9C8\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4.";
+    return { id: key, title: `\uD53C\uADF8\uB9C8 \uBB38\uAD6C \u300C${text}\u300D`, ok: false, message: `[\uD53C\uADF8\uB9C8 \uCC28\uC774] ${message}`, ignoreKey: key, ignoreHash: figmaHash, ignored: isIgnored(ignores, key, figmaHash) };
+  };
+  return diff.notInFigma.map((text) => toCheck(text, "extra"));
+}
+function docsMismatchChecks(rules, figmaTexts, screenText, ignores) {
+  if (figmaTexts.length === 0) return [];
+  const figma = figmaTexts.map(squash).join("\0");
+  const screen = squash(screenText);
+  return rules.filter((rule) => rule.kind === "copy" && rule.expected && screen.includes(squash(rule.expected)) && !figma.includes(squash(rule.expected))).map((rule) => {
+    const key = `docs:${rule.id}`;
+    return { id: key, title: rule.statement, ok: false, message: `[${findingLabels["docs-mismatch"]}] \uC815\uCC45\xB7\uC571 \uBB38\uAD6C \u300C${rule.expected}\u300D\uAC00 \uD53C\uADF8\uB9C8\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4. \xB7 \u300C${rule.pageTitle}\u300D`, finding: "docs-mismatch", ignoreKey: key, ignoreHash: rule.pageHash, ignored: isIgnored(ignores, key, rule.pageHash), pageId: rule.pageId };
+  });
+}
+var hasBugCandidate = (checks) => checks.some((check) => !check.ok && !check.ignored && check.finding === "bug-candidate");
+
+export {
+  isIgnored,
+  rulesForScreen,
+  screenTextHash,
+  compareCopyRules,
+  situationalRules,
+  diffFigmaCopy,
+  figmaChecks,
+  docsMismatchChecks,
+  hasBugCandidate
+};

package/dist/chunk-VGPCTMUA.js

@@ -0,0 +1,258 @@
+import {
+  diffSnapshots,
+  emptySnapshot
+} from "./chunk-F6PZOBU6.js";
+
+// packages/engine/src/policy/claude.ts
+import { spawn } from "child_process";
+var claudeTimeoutMs = 5 * 6e4;
+var ClaudeError = class extends Error {
+};
+var askClaude = (prompt, options = {}) => new Promise((resolve, reject) => {
+  const args = ["-p", "--output-format", "json", "--tools", options.allowRead ? "Read" : ""];
+  if (options.allowRead) args.push("--allowedTools", "Read");
+  const child = spawn("claude", args, { stdio: ["pipe", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  const timer = setTimeout(() => {
+    child.kill("SIGTERM");
+    reject(new ClaudeError(`Claude \uC751\uB2F5\uC774 ${claudeTimeoutMs / 6e4}\uBD84 \uC548\uC5D0 \uC624\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4.`));
+  }, claudeTimeoutMs);
+  child.stdout.on("data", (chunk) => stdout += chunk.toString("utf8"));
+  child.stderr.on("data", (chunk) => stderr += chunk.toString("utf8"));
+  child.on("error", (error) => {
+    clearTimeout(timer);
+    reject(new ClaudeError(`claude \uC2E4\uD589 \uC2E4\uD328: ${error.message}`));
+  });
+  child.on("close", () => {
+    clearTimeout(timer);
+    try {
+      const parsed = JSON.parse(stdout);
+      if (parsed.is_error || typeof parsed.result !== "string") throw new ClaudeError(parsed.result ?? "Claude \uC751\uB2F5\uC774 \uBE44\uC5C8\uC2B5\uB2C8\uB2E4.");
+      resolve(parsed.result);
+    } catch (error) {
+      reject(error instanceof ClaudeError ? error : new ClaudeError(`Claude \uC751\uB2F5\uC744 \uC77D\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${(stderr || stdout).slice(0, 200)}`));
+    }
+  });
+  child.stdin.end(prompt);
+});
+
+// packages/engine/src/policy/store.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import path from "path";
+var sourcesFile = path.resolve("policy/sources.json");
+var policyRoot = path.resolve("test-results/policy");
+function readSources(file = sourcesFile) {
+  if (!existsSync(file)) return { pages: [] };
+  const parsed = JSON.parse(readFileSync(file, "utf8"));
+  return { pages: Array.isArray(parsed.pages) ? parsed.pages : [] };
+}
+var snapshotFile = (root) => path.join(root, "snapshot.json");
+var changesFile = (root) => path.join(root, "changes.jsonl");
+function readSnapshot(root = policyRoot) {
+  try {
+    return JSON.parse(readFileSync(snapshotFile(root), "utf8"));
+  } catch {
+    return emptySnapshot;
+  }
+}
+function recordSnapshot(next, root = policyRoot) {
+  const changes = diffSnapshots(readSnapshot(root), next);
+  mkdirSync(root, { recursive: true });
+  const temp = `${snapshotFile(root)}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(next, null, 2)}
+`);
+  renameSync(temp, snapshotFile(root));
+  const lines = changes.map((change) => {
+    const record = { at: next.checkedAt, kind: change.kind, id: change.page.id, title: change.page.title, version: change.page.version, fromVersion: change.before?.version, hash: change.page.hash };
+    return JSON.stringify(record);
+  });
+  if (lines.length > 0) appendFileSync(changesFile(root), `${lines.join("\n")}
+`);
+  return changes;
+}
+function readChanges(limit, root = policyRoot) {
+  if (!existsSync(changesFile(root))) return [];
+  const records = readFileSync(changesFile(root), "utf8").split("\n").filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+  return records.slice(-limit).reverse();
+}
+
+// packages/engine/src/policy/rules-store.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import path2 from "path";
+var ignoredFile = path2.resolve("policy/ignored.json");
+var rulesDir = (root) => path2.join(root, "rules");
+var figmaFile = (root) => path2.join(root, "figma.json");
+var judgeFile = (root) => path2.join(root, "judge-cache.json");
+var screensFile = (root) => path2.join(root, "screens.json");
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(readFileSync2(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonFile(file, value) {
+  mkdirSync2(path2.dirname(file), { recursive: true });
+  const temp = `${file}.tmp`;
+  writeFileSync2(temp, `${JSON.stringify(value, null, 2)}
+`);
+  renameSync2(temp, file);
+}
+function readPageRules(pageId, root = policyRoot) {
+  return readJson(path2.join(rulesDir(root), `${pageId}.json`), null);
+}
+function writePageRules(rules, root = policyRoot) {
+  writeJsonFile(path2.join(rulesDir(root), `${rules.pageId}.json`), rules);
+}
+function removePageRules(pageId, root = policyRoot) {
+  rmSync(path2.join(rulesDir(root), `${pageId}.json`), { force: true });
+}
+function readAllPageRules(root = policyRoot) {
+  if (!existsSync2(rulesDir(root))) return [];
+  return readdirSync(rulesDir(root)).filter((name) => name.endsWith(".json")).flatMap((name) => {
+    const rules = readJson(path2.join(rulesDir(root), name), null);
+    return rules ? [rules] : [];
+  });
+}
+function readIgnores(file = ignoredFile) {
+  const parsed = readJson(file, {});
+  return Array.isArray(parsed.items) ? parsed.items : [];
+}
+function addIgnore(item, file = ignoredFile) {
+  const items = readIgnores(file).filter((existing) => !(existing.key === item.key && existing.hash === item.hash));
+  writeJsonFile(file, { items: [...items, item] });
+}
+function removeIgnore(key, hash, file = ignoredFile) {
+  writeJsonFile(file, { items: readIgnores(file).filter((item) => !(item.key === key && item.hash === hash)) });
+}
+var readFigmaCache = (root = policyRoot) => readJson(figmaFile(root), {});
+var writeFigmaCache = (cache, root = policyRoot) => writeJsonFile(figmaFile(root), cache);
+var readJudgeCache = (root = policyRoot) => readJson(judgeFile(root), {});
+var writeJudgeCache = (cache, root = policyRoot) => writeJsonFile(judgeFile(root), cache);
+var readScreenHashes = (root = policyRoot) => readJson(screensFile(root), {});
+var writeScreenHashes = (hashes, root = policyRoot) => writeJsonFile(screensFile(root), hashes);
+
+// packages/engine/src/policy/front-figma.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import path3 from "path";
+
+// packages/core/src/policy/front-figma.ts
+function routeOfFile(file, appDir = "app") {
+  const prefix = appDir.split("/").filter(Boolean);
+  const all = file.split("/");
+  if (prefix.some((part, index) => all[index] !== part)) return null;
+  const parts = ["app", ...all.slice(prefix.length)];
+  const route = [];
+  for (const part of parts.slice(1, -1)) {
+    if (part.startsWith("_") || part.startsWith("@")) break;
+    if (part.startsWith("(") && part.endsWith(")")) continue;
+    route.push(part.startsWith("[") ? "*" : part);
+  }
+  return `/${route.join("/")}`;
+}
+var linkPattern = /figma\.com\/(?:design|file|proto)\/([A-Za-z0-9]+)[^"'`\s<>]*?node-id=([0-9]+)(?:-|%3A|:)([0-9]+)/g;
+var commentPattern = /Figma\s+([0-9]+):([0-9]+)/g;
+function parseGrepLine(line, ref) {
+  const body = line.startsWith(`${ref}:`) ? line.slice(ref.length + 1) : line;
+  const match = /^([^:]+):\d+:(.*)$/.exec(body);
+  return match ? { file: match[1], text: match[2] } : null;
+}
+function buildFrontFigmaMap(lines, appDir = "app") {
+  const links = /* @__PURE__ */ new Map();
+  const comments = /* @__PURE__ */ new Map();
+  const keyCount = /* @__PURE__ */ new Map();
+  const add = (map, route, value) => map.set(route, (map.get(route) ?? /* @__PURE__ */ new Set()).add(value));
+  for (const { file, text } of lines) {
+    const route = routeOfFile(file, appDir);
+    if (!route) continue;
+    for (const match of text.matchAll(linkPattern)) {
+      add(links, route, `${match[1]}:${match[2]}:${match[3]}`);
+      const counts = keyCount.get(route) ?? /* @__PURE__ */ new Map();
+      keyCount.set(route, counts.set(match[1], (counts.get(match[1]) ?? 0) + 1));
+    }
+    for (const match of text.matchAll(commentPattern)) add(comments, route, `${match[1]}:${match[2]}`);
+  }
+  const topKey = (counts) => [...(counts ?? /* @__PURE__ */ new Map()).entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+  const allCounts = /* @__PURE__ */ new Map();
+  for (const counts of keyCount.values()) for (const [key, count] of counts) allCounts.set(key, (allCounts.get(key) ?? 0) + count);
+  const fallbackKey = topKey(allCounts);
+  const result = {};
+  for (const route of /* @__PURE__ */ new Set([...links.keys(), ...comments.keys()])) {
+    const refs = new Set(links.get(route));
+    const key = topKey(keyCount.get(route)) ?? fallbackKey;
+    if (key) for (const node of comments.get(route) ?? []) refs.add(`${key}:${node}`);
+    if (refs.size > 0) result[route] = [...refs].sort();
+  }
+  return result;
+}
+
+// packages/engine/src/policy/front-figma.ts
+var defaultFrontRef = "origin/main";
+var grepMaxBuffer = 32 * 1024 * 1024;
+var mapFile = (root) => path3.join(root, "front-figma.json");
+function readFrontFigmaMap(root = policyRoot) {
+  if (!existsSync3(mapFile(root))) return null;
+  try {
+    return JSON.parse(readFileSync3(mapFile(root), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function buildFrontFigma(frontRoot, ref = defaultFrontRef, now = /* @__PURE__ */ new Date(), root = policyRoot, appDir = "app") {
+  const git = (...args) => execFileSync("git", ["-C", frontRoot, ...args], { encoding: "utf8", maxBuffer: grepMaxBuffer });
+  const [remote, ...branch] = ref.split("/");
+  try {
+    git("fetch", "-q", remote, branch.join("/"));
+  } catch {
+  }
+  const commit = git("rev-parse", "--short", ref).trim();
+  let output = "";
+  try {
+    output = git("grep", "-n", "-E", "figma\\.com/(design|file|proto)/|Figma [0-9]+:[0-9]+", ref, "--", appDir);
+  } catch (error) {
+    if (error.status !== 1) throw error;
+  }
+  const lines = output.split("\n").map((line) => parseGrepLine(line, ref)).filter((line) => line !== null);
+  const map = { ref, commit, builtAt: now.toISOString(), routes: buildFrontFigmaMap(lines, appDir) };
+  writeJsonFile(mapFile(root), map);
+  return map;
+}
+
+// packages/server/src/scenarios.ts
+function farmScenarios(app) {
+  const excluded = new Set(app.excludedScenarioPaths);
+  return app.scenarios.filter((scenario) => !excluded.has(scenario.path));
+}
+
+export {
+  askClaude,
+  policyRoot,
+  readSources,
+  readSnapshot,
+  recordSnapshot,
+  readChanges,
+  readPageRules,
+  writePageRules,
+  removePageRules,
+  readAllPageRules,
+  readIgnores,
+  addIgnore,
+  removeIgnore,
+  readFigmaCache,
+  writeFigmaCache,
+  readJudgeCache,
+  writeJudgeCache,
+  readScreenHashes,
+  writeScreenHashes,
+  readFrontFigmaMap,
+  buildFrontFigma,
+  farmScenarios
+};