@ahnseungchan/device-farm 0.0.0-stage → 0.1.1

package/dist/chunk-PLMSQ5KF.js

@@ -0,0 +1,173 @@
+import {
+  isPrdName,
+  validateGenerated
+} from "./chunk-SWW42KTA.js";
+import {
+  tabNamesOf
+} from "./chunk-NJNTEWXE.js";
+
+// packages/core/src/flows/map-flow.ts
+function mapRulesOf(app) {
+  return { homePath: app.homePath, homeTabName: app.homeTabName, tabPaths: app.tabPaths, forbiddenClickNames: app.guard.forbiddenClickNames };
+}
+var mapFlowPrd = "\uD654\uBA74 \uC9C0\uB3C4";
+var startCursorOf = (rules) => ({ path: rules.homePath, texts: [] });
+function blocksAt(edges, path2, rules) {
+  const tabs = tabNamesOf(rules).map((name) => ({ kind: "tab", step: { type: "click", target: { role: "link", name } }, to: rules.tabPaths[name], texts: [] }));
+  const own = edges.flatMap((edge) => {
+    if (edge.from !== path2 || rules.forbiddenClickNames.includes(edge.name)) return [];
+    const step = { type: "click", target: { role: edge.role, name: edge.name } };
+    if (edge.kind === "navigate" && edge.to) return [{ kind: "navigate", step, to: edge.to, texts: edge.texts ?? [] }];
+    if (edge.kind === "popup") return [{ kind: "popup", step, to: path2, texts: edge.texts ?? [] }];
+    return [];
+  });
+  return [...tabs, ...own];
+}
+function advance(edges, cursor, step, rules) {
+  if (step.type === "home") return startCursorOf(rules);
+  if (step.type === "expectText") {
+    return cursor.texts.includes(step.text) ? cursor : `\u300C${step.text}\u300D\uB294 \uC55E \uBE14\uB85D\uC744 \uB204\uB978 \uB4A4 \uC9C0\uB3C4\uC5D0 \uB0A8\uC740 \uBB38\uAD6C\uAC00 \uC544\uB2D9\uB2C8\uB2E4.`;
+  }
+  const block = blocksAt(edges, cursor.path, rules).find(
+    (item) => item.step.target.role === step.target.role && item.step.target.name === step.target.name
+  );
+  if (!block) return `\u300C${step.target.name}\u300D\uB294 ${cursor.path} \uD654\uBA74 \uC9C0\uB3C4\uC5D0 \uC5C6\uB294 \uBC84\uD2BC\uC785\uB2C8\uB2E4.`;
+  return { path: block.to, texts: block.texts };
+}
+function replay(edges, steps, rules) {
+  let cursor = startCursorOf(rules);
+  for (const [index, step] of steps.entries()) {
+    const next = advance(edges, cursor, step, rules);
+    if (typeof next === "string") return `${index + 1}\uBC88\uC9F8 \uBE14\uB85D: ${next}`;
+    cursor = next;
+  }
+  return cursor;
+}
+function mapFlowError(edges, steps, rules) {
+  if (!steps.some((step) => step.type === "click")) return "\uB204\uB974\uB294 \uBE14\uB85D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  if (!steps.some((step) => step.type === "expectText")) return "\uBB38\uAD6C \uD655\uC778 \uBE14\uB85D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
+  const result = replay(edges, steps, rules);
+  return typeof result === "string" ? result : null;
+}
+
+// packages/engine/src/flows/store.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "fs";
+import path from "path";
+var flowSources = ["ai_generated", "map_built", "recorded"];
+var flowDirs = {
+  ready: path.resolve("scenarios/flows"),
+  generated: path.resolve("test-results/flows/generated")
+};
+var prdSearchRoots = ["app", "docs/specs"];
+var skippedDirs = /* @__PURE__ */ new Set(["node_modules", ".git", ".next"]);
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(file, value) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(value, null, 2)}
+`);
+}
+function prdRoot() {
+  const root = process.env.FLOW_PRD_ROOT?.trim();
+  return root && existsSync(root) ? realpathSync(root) : null;
+}
+function walkMarkdown(dir, inSpecs, out) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (skippedDirs.has(entry.name)) continue;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) walkMarkdown(full, inSpecs || entry.name === "specs", out);
+    else if (inSpecs && entry.name.endsWith(".md")) out.push(full);
+  }
+}
+function listPrds(root = prdRoot()) {
+  if (!root) return [];
+  const files = [];
+  for (const sub of prdSearchRoots) {
+    const dir = path.join(root, sub);
+    if (existsSync(dir)) walkMarkdown(dir, sub === "docs/specs", files);
+  }
+  return files.map((file) => path.relative(root, file).split(path.sep).join("/")).filter(isPrdName).sort();
+}
+function readPrd(name, root = prdRoot()) {
+  if (!root || !isPrdName(name)) return null;
+  const file = path.resolve(root, name);
+  if (!file.startsWith(root + path.sep) || !existsSync(file)) return null;
+  return readFileSync(file, "utf8");
+}
+function prdHash(body) {
+  return createHash("sha256").update(body, "utf8").digest("hex");
+}
+var hashFile = (dirs) => path.join(dirs.generated, "hashes.json");
+var candidateFile = (dirs) => path.join(dirs.generated, "scenarios.json");
+function readHashes(dirs = flowDirs) {
+  return readJson(hashFile(dirs), {});
+}
+function writeHash(name, hash, dirs = flowDirs) {
+  writeJson(hashFile(dirs), { ...readHashes(dirs), [name]: hash });
+}
+function readCandidates(dirs = flowDirs) {
+  const parsed = readJson(candidateFile(dirs), { items: [] });
+  return Array.isArray(parsed.items) ? parsed.items : [];
+}
+function writeCandidates(prd, items, dirs = flowDirs) {
+  writeJson(candidateFile(dirs), { items: [...readCandidates(dirs).filter((item) => item.prd !== prd), ...items] });
+}
+function addCandidate(item, dirs = flowDirs) {
+  writeJson(candidateFile(dirs), { items: [...readCandidates(dirs).filter((entry) => entry.id !== item.id), item] });
+}
+function readReady(dirs = flowDirs) {
+  if (!existsSync(dirs.ready)) return [];
+  return readdirSync(dirs.ready).filter((name) => name.endsWith(".json")).sort().flatMap((name) => {
+    const parsed = readJson(path.join(dirs.ready, name), null);
+    return parsed && parsed.status === "ready" && flowSources.includes(parsed.source) ? [parsed] : [];
+  });
+}
+function acceptGenerated(items, prd, prdBody, forbiddenClickNames, dirs = flowDirs) {
+  const readyIds = new Set(readReady(dirs).map((item) => item.id));
+  return items.map((item, index) => validateGenerated(item, index, readyIds, prd, prdBody, forbiddenClickNames));
+}
+function readyDocument(item) {
+  return { id: item.id, name: item.name, source: item.source, status: "ready", prd: item.prd, requirement: item.requirement, steps: item.steps };
+}
+function confirmFlow(id, dirs = flowDirs) {
+  const items = readCandidates(dirs);
+  const item = items.find((entry) => entry.id === id && entry.status === "generated");
+  if (!item || !item.proposal || item.proposal === "keep") return false;
+  const file = path.join(dirs.ready, `${item.id}.json`);
+  if (item.proposal === "delete") {
+    if (existsSync(file)) unlinkSync(file);
+  } else {
+    writeJson(file, readyDocument(item));
+  }
+  writeJson(candidateFile(dirs), { items: items.filter((entry) => entry.id !== id) });
+  return true;
+}
+function confirmFlows(ids, dirs = flowDirs) {
+  const targets = ids ?? readCandidates(dirs).filter((item) => item.status === "generated").map((item) => item.id);
+  return targets.filter((id) => confirmFlow(id, dirs)).length;
+}
+
+export {
+  mapRulesOf,
+  mapFlowPrd,
+  mapFlowError,
+  flowDirs,
+  prdRoot,
+  listPrds,
+  readPrd,
+  prdHash,
+  readHashes,
+  writeHash,
+  readCandidates,
+  writeCandidates,
+  addCandidate,
+  readReady,
+  acceptGenerated,
+  confirmFlows
+};

package/dist/chunk-PYZWMVJ6.js

@@ -0,0 +1,302 @@
+import {
+  askClaude,
+  buildFrontFigma,
+  policyRoot,
+  readAllPageRules,
+  readChanges,
+  readFigmaCache,
+  readFrontFigmaMap,
+  readPageRules,
+  readSnapshot,
+  readSources,
+  recordSnapshot,
+  removePageRules,
+  writeFigmaCache,
+  writePageRules
+} from "./chunk-VGPCTMUA.js";
+import {
+  buildPageRules,
+  extractPrompt,
+  parseExtraction,
+  shortHash,
+  storageToText
+} from "./chunk-F6PZOBU6.js";
+
+// packages/engine/src/policy/confluence.ts
+import { createHash } from "crypto";
+var defaultPolicyTitleQuery = "\uC815\uCC45";
+var searchPageSize = 50;
+var pageConcurrency = 5;
+function confluenceConfigFromEnv(source, env = process.env) {
+  const email = env.CONFLUENCE_EMAIL?.trim();
+  const token = env.CONFLUENCE_API_TOKEN?.trim();
+  const cloudId = env.CONFLUENCE_CLOUD_ID?.trim() || source?.cloudId;
+  const spaceKey = env.CONFLUENCE_SPACE_KEY?.trim() || source?.spaceKey;
+  if (!email || !token || !cloudId || !spaceKey) return null;
+  return { email, token, cloudId, spaceKey, titleQuery: source?.titleQuery || defaultPolicyTitleQuery, siteUrl: (source?.siteUrl ?? "").replace(/\/+$/, "") };
+}
+var wikiBase = (config) => `https://api.atlassian.com/ex/confluence/${config.cloudId}/wiki`;
+var ConfluenceError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+async function getJson(config, pathAndQuery, fetchImpl) {
+  const auth = Buffer.from(`${config.email}:${config.token}`).toString("base64");
+  const response = await fetchImpl(`${wikiBase(config)}${pathAndQuery}`, { headers: { Authorization: `Basic ${auth}`, Accept: "application/json" } });
+  if (!response.ok) throw new ConfluenceError(response.status, `Confluence ${response.status}: ${pathAndQuery.split("?")[0]}`);
+  return await response.json();
+}
+async function searchPolicyPages(config, fetchImpl) {
+  const cql = `space=${config.spaceKey} AND type=page AND title~"${config.titleQuery}"`;
+  let next = `/rest/api/search?cql=${encodeURIComponent(cql)}&limit=${searchPageSize}`;
+  const pages = [];
+  while (next) {
+    const response = await getJson(config, next, fetchImpl);
+    for (const item of response.results) if (item.content?.type === "page") pages.push({ id: item.content.id, title: item.content.title });
+    next = response._links?.next;
+  }
+  return pages;
+}
+function hashBody(body) {
+  return createHash("sha256").update(body, "utf8").digest("hex");
+}
+async function readPolicyPageWithBody(config, id, fetchImpl) {
+  const page = await getJson(config, `/api/v2/pages/${encodeURIComponent(id)}?body-format=storage`, fetchImpl);
+  const storage = page.body?.storage?.value ?? "";
+  return {
+    page: {
+      id: page.id,
+      title: page.title,
+      version: page.version.number,
+      modifiedAt: page.version.createdAt,
+      hash: hashBody(storage),
+      webUrl: `${config.siteUrl || wikiBase(config)}${page._links?.webui ?? `/pages/${page.id}`}`
+    },
+    storage
+  };
+}
+async function readPolicyPage(config, id, fetchImpl) {
+  return (await readPolicyPageWithBody(config, id, fetchImpl)).page;
+}
+async function fetchPolicySnapshot(config, registeredIds, fetchImpl, now = () => /* @__PURE__ */ new Date()) {
+  const found = await searchPolicyPages(config, fetchImpl);
+  const ids = [.../* @__PURE__ */ new Set([...found.map((page) => page.id), ...registeredIds])];
+  const pages = {};
+  const failed = [];
+  for (let start = 0; start < ids.length; start += pageConcurrency) {
+    await Promise.all(
+      ids.slice(start, start + pageConcurrency).map(async (id) => {
+        try {
+          pages[id] = await readPolicyPage(config, id, fetchImpl);
+        } catch (error) {
+          failed.push({ id, message: error instanceof Error ? error.message : String(error) });
+        }
+      })
+    );
+  }
+  return { snapshot: { checkedAt: now().toISOString(), pages }, failed };
+}
+
+// packages/engine/src/policy/figma.ts
+function figmaRefs(storage) {
+  const refs = /* @__PURE__ */ new Set();
+  const pattern = /figma\.com\/(?:design|file|proto)\/([A-Za-z0-9]+)[^"'\s<>]*?node-id=([0-9]+(?:-|%3A|:)[0-9]+)/g;
+  for (const match of storage.replaceAll("&amp;", "&").matchAll(pattern)) {
+    refs.add(`${match[1]}:${decodeURIComponent(match[2]).replace("-", ":")}`);
+  }
+  return [...refs].sort();
+}
+function collectTexts(node, into) {
+  if (!node) return;
+  if (node.type === "TEXT" && node.characters?.trim()) into.push(node.characters.trim());
+  for (const child of node.children ?? []) collectTexts(child, into);
+}
+async function fetchFigmaTexts(token, refs, fetchImpl) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const [fileKey, ...rest] = ref.split(":");
+    byFile.set(fileKey, [...byFile.get(fileKey) ?? [], rest.join(":")]);
+  }
+  const result = {};
+  for (const [fileKey, ids] of byFile) {
+    const response = await fetchImpl(`https://api.figma.com/v1/files/${fileKey}/nodes?ids=${encodeURIComponent(ids.join(","))}`, { headers: { "X-Figma-Token": token } });
+    if (!response.ok) throw new Error(`Figma ${response.status}: ${fileKey}`);
+    const body = await response.json();
+    for (const id of ids) {
+      const texts = [];
+      collectTexts(body.nodes?.[id]?.document, texts);
+      result[`${fileKey}:${id}`] = { hash: shortHash(texts.join("\n")), texts };
+    }
+  }
+  return result;
+}
+
+// packages/engine/src/policy/extract.ts
+var pagesToExtract = (snapshot, root = policyRoot) => Object.values(snapshot.pages).filter((page) => readPageRules(page.id, root)?.pageHash !== page.hash);
+async function extractPage(pageId, deps) {
+  const root = deps.root ?? policyRoot;
+  const { page, storage } = await readPolicyPageWithBody(deps.config, pageId, deps.fetchImpl);
+  const bodyText = storageToText(storage);
+  const { screens, candidates } = parseExtraction(await deps.ask(extractPrompt(page.title, bodyText, deps.knownScreens, deps.appName)));
+  const { rules, dropped } = buildPageRules(page, bodyText, candidates, readPageRules(page.id, root)?.rules ?? []);
+  writePageRules(
+    { pageId: page.id, pageTitle: page.title, pageHash: page.hash, extractedAt: (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString(), screens, figma: figmaRefs(storage), rules, dropped },
+    root
+  );
+  deps.log(`\uC815\uCC45 \uADDC\uCE59 \u300C${page.title}\u300D ${rules.length}\uAC1C \xB7 \uBC84\uB9BC ${dropped.length}\uAC1C`);
+}
+async function refreshRules(snapshot, deps) {
+  const root = deps.root ?? policyRoot;
+  const targets = pagesToExtract(snapshot, root);
+  const failed = [];
+  let extracted = 0;
+  for (const [index, page] of targets.entries()) {
+    deps.onProgress?.(index, targets.length);
+    try {
+      await extractPage(page.id, deps);
+      extracted += 1;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failed.push({ id: page.id, message });
+      deps.log(`\uC815\uCC45 \uADDC\uCE59 \uBF51\uAE30 \uC2E4\uD328 \u300C${page.title}\u300D: ${message}`);
+    }
+  }
+  const stale = readAllPageRules(root).filter((rules) => !snapshot.pages[rules.pageId]);
+  for (const rules of stale) removePageRules(rules.pageId, root);
+  return { extracted, removed: stale.length, failed };
+}
+
+// packages/core/src/policy/schedule.ts
+var policyCheckHour = 2;
+function lastScheduledAt(now, hour = policyCheckHour) {
+  const scheduled = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hour, 0, 0, 0);
+  if (scheduled.getTime() > now.getTime()) scheduled.setDate(scheduled.getDate() - 1);
+  return scheduled;
+}
+function nextScheduledAt(now, hour = policyCheckHour) {
+  const next = lastScheduledAt(now, hour);
+  next.setDate(next.getDate() + 1);
+  return next;
+}
+function isPolicyCheckDue(lastCheckedAt, now, hour = policyCheckHour) {
+  const last = lastCheckedAt ? Date.parse(lastCheckedAt) : Number.NaN;
+  return !Number.isFinite(last) || last < lastScheduledAt(now, hour).getTime();
+}
+
+// packages/server/src/policy-watch.ts
+var policyPollMs = 60 * 6e4;
+var recentChanges = 50;
+function rulesSummary() {
+  return readAllPageRules().map((page) => ({
+    pageId: page.pageId,
+    pageTitle: page.pageTitle,
+    extractedAt: page.extractedAt,
+    screens: page.screens,
+    figma: page.figma.length,
+    rules: page.rules,
+    dropped: page.dropped
+  }));
+}
+function refreshFrontFigma(figma, log) {
+  const frontRoot = figma.frontRepo?.trim() || process.env.FLOW_PRD_ROOT?.trim();
+  if (!frontRoot) return;
+  try {
+    const map = buildFrontFigma(frontRoot, process.env.FARM_FRONT_REF?.trim() || figma.ref, void 0, void 0, figma.appDir);
+    log(`\uD504\uB860\uD2B8 ${map.ref}@${map.commit} \uD654\uBA74 ${Object.keys(map.routes).length}\uAC1C\uC5D0 \uD53C\uADF8\uB9C8 \uB178\uB4DC \uC5F0\uACB0`);
+  } catch (error) {
+    log(`\uD504\uB860\uD2B8 \uD53C\uADF8\uB9C8 \uC5F0\uACB0 \uC2E4\uD328: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function refreshFigma(fetchImpl, log) {
+  const token = process.env.FIGMA_TOKEN?.trim();
+  const front = Object.values(readFrontFigmaMap()?.routes ?? {}).flat();
+  const refs = [.../* @__PURE__ */ new Set([...readAllPageRules().flatMap((page) => page.figma), ...front])];
+  if (!token || refs.length === 0) return;
+  const texts = await fetchFigmaTexts(token, refs, fetchImpl);
+  writeFigmaCache({ ...readFigmaCache(), ...texts });
+  log(`\uD53C\uADF8\uB9C8 \uB178\uB4DC ${Object.keys(texts).length}\uAC1C \uBB38\uAD6C \uC77D\uC74C`);
+}
+function startPolicyWatch(deps) {
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  const fetchImpl = deps.fetchImpl ?? ((url, init) => fetch(url, init));
+  const ask = deps.ask ?? askClaude;
+  let running = false;
+  let lastError = null;
+  let failed = [];
+  let extractFailed = [];
+  let progress = null;
+  const run = async () => {
+    const config = confluenceConfigFromEnv(deps.app.policy.confluence);
+    if (!config || running) return;
+    running = true;
+    try {
+      const result = await fetchPolicySnapshot(config, readSources().pages.map((page) => page.pageId), fetchImpl, now);
+      const changes = recordSnapshot(result.snapshot);
+      failed = result.failed;
+      lastError = null;
+      deps.log(`\uC815\uCC45 ${Object.keys(result.snapshot.pages).length}\uAC1C \uD655\uC778 \xB7 \uBC14\uB01C ${changes.length}\uAC1C${failed.length ? ` \xB7 \uC77D\uAE30 \uC2E4\uD328 ${failed.length}\uAC1C` : ""}`);
+      const refreshed = await refreshRules(result.snapshot, {
+        config,
+        ask,
+        fetchImpl,
+        knownScreens: deps.knownScreens(),
+        appName: deps.app.name,
+        log: deps.log,
+        now,
+        onProgress: (done, total) => progress = { done, total }
+      });
+      extractFailed = refreshed.failed;
+      refreshFrontFigma(deps.app.figma, deps.log);
+      await refreshFigma(fetchImpl, deps.log);
+    } catch (error) {
+      lastError = error instanceof Error ? error.message : String(error);
+      deps.log(`\uC815\uCC45 \uD655\uC778 \uC2E4\uD328: ${lastError}`);
+    } finally {
+      running = false;
+      progress = null;
+    }
+  };
+  const tick = () => {
+    if (isPolicyCheckDue(readSnapshot().checkedAt || null, now())) void run();
+  };
+  tick();
+  const timer = setInterval(tick, policyPollMs);
+  timer.unref();
+  return {
+    state: () => {
+      const snapshot = readSnapshot();
+      return {
+        configured: confluenceConfigFromEnv(deps.app.policy.confluence) !== null,
+        figmaConfigured: Boolean(process.env.FIGMA_TOKEN?.trim()),
+        running,
+        progress,
+        checkedAt: snapshot.checkedAt || null,
+        nextAt: nextScheduledAt(now()).toISOString(),
+        lastError,
+        failed,
+        extractFailed,
+        pages: Object.values(snapshot.pages).sort((a, b) => a.modifiedAt < b.modifiedAt ? 1 : -1),
+        changes: readChanges(recentChanges),
+        rules: rulesSummary()
+      };
+    },
+    checkNow: () => {
+      if (running) return false;
+      void run();
+      return true;
+    },
+    stop: () => clearInterval(timer)
+  };
+}
+
+export {
+  confluenceConfigFromEnv,
+  fetchPolicySnapshot,
+  extractPage,
+  refreshFrontFigma,
+  refreshFigma,
+  startPolicyWatch
+};