canicode 0.10.3 → 0.10.4

package/skills/canicode-roundtrip/helpers.js

@@ -272,10 +272,11 @@ ${footer}`;
       if (!id) continue;
       if (verdict.has(id)) continue;
       const node = await figma.getNodeByIdAsync(id);
-      const isUnwritable = node === null || node.remote === true;
+      const writability = resolveWritability(node);
+      const isUnwritable = writability.isUnwritable;
       verdict.set(id, isUnwritable ? "unwritable" : "writable");
       if (isUnwritable) {
-        const name = typeof node?.name === "string" && node.name || q.instanceContext?.sourceComponentName || id;
+        const name = typeof writability.componentName === "string" && writability.componentName || typeof node?.name === "string" && node.name || q.instanceContext?.sourceComponentName || id;
         if (!seenName.has(name)) {
           seenName.add(name);
           unwritableNames.push(name);
@@ -293,11 +294,226 @@ ${footer}`;
       partiallyUnwritable: unwritableCount > 0 && unwritableCount < totalCount
     };
   }
+  function resolveWritability(node) {
+    if (node === null) return { isUnwritable: true };
+    if ("remote" in node && typeof node.remote === "boolean") {
+      return { isUnwritable: node.remote === true };
+    }
+    const containing = findContainingComponent(node);
+    if (!containing) {
+      return { isUnwritable: false };
+    }
+    const isUnwritable = "remote" in containing && containing.remote === true;
+    return {
+      isUnwritable,
+      ...isUnwritable && typeof containing.name === "string" ? { componentName: containing.name } : {}
+    };
+  }
+  function findContainingComponent(node) {
+    let cur = node;
+    for (let i = 0; i < 100 && cur; i++) {
+      if (cur.type === "COMPONENT" || cur.type === "COMPONENT_SET") return cur;
+      cur = cur.parent ?? null;
+    }
+    return null;
+  }
+
+  // src/core/roundtrip/read-acknowledgments.ts
+  var FOOTER_RE = /—\s+\*([A-Za-z0-9-]+)\*\s*$/;
+  var LEGACY_PREFIX_RE = /^\*\*\[canicode\]\s+([A-Za-z0-9-]+)\*\*/;
+  function extractAcknowledgmentsFromNode(node, canicodeCategoryIds) {
+    if (!node || !("annotations" in node)) return [];
+    const annotations = node.annotations ?? [];
+    if (annotations.length === 0) return [];
+    const out = [];
+    for (const a of annotations) {
+      const text = (typeof a.labelMarkdown === "string" && a.labelMarkdown.length > 0 ? a.labelMarkdown : "") || (typeof a.label === "string" && a.label.length > 0 ? a.label : "");
+      if (!text) continue;
+      if (canicodeCategoryIds) {
+        if (!a.categoryId || !canicodeCategoryIds.has(a.categoryId)) continue;
+      }
+      const ruleId = extractRuleId(text);
+      if (!ruleId) continue;
+      out.push({ nodeId: node.id, ruleId });
+    }
+    return out;
+  }
+  function extractRuleId(text) {
+    const footer = FOOTER_RE.exec(text);
+    if (footer) return footer[1] ?? null;
+    const legacy = LEGACY_PREFIX_RE.exec(text);
+    if (legacy) return legacy[1] ?? null;
+    return null;
+  }
+  async function readCanicodeAcknowledgments(rootNodeId, categories) {
+    const root = await figma.getNodeByIdAsync(rootNodeId);
+    if (!root) return [];
+    const canicodeCategoryIds = categories ? new Set(
+      [
+        categories.gotcha,
+        categories.flag,
+        categories.fallback,
+        categories.legacyAutoFix
+      ].filter((id) => typeof id === "string" && id.length > 0)
+    ) : void 0;
+    const out = [];
+    walk(root, canicodeCategoryIds, out);
+    return out;
+  }
+  function walk(node, canicodeCategoryIds, out) {
+    try {
+      const local = extractAcknowledgmentsFromNode(node, canicodeCategoryIds);
+      for (const a of local) out.push(a);
+    } catch {
+    }
+    const children = node.children;
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        if (child && typeof child === "object") walk(child, canicodeCategoryIds, out);
+      }
+    }
+  }
+
+  // src/core/roundtrip/compute-roundtrip-tally.ts
+  function computeRoundtripTally(args) {
+    const { stepFourReport, reanalyzeResponse } = args;
+    const { resolved, annotated, definitionWritten, skipped } = stepFourReport;
+    const { issueCount, acknowledgedCount } = reanalyzeResponse;
+    if (acknowledgedCount > issueCount) {
+      throw new Error(
+        `computeRoundtripTally: reanalyzeResponse.acknowledgedCount (${acknowledgedCount}) cannot exceed issueCount (${issueCount}). Acknowledged issues are a subset of remaining issues.`
+      );
+    }
+    return {
+      X: resolved,
+      Y: annotated,
+      Z: definitionWritten,
+      W: skipped,
+      N: resolved + annotated + definitionWritten + skipped,
+      V: issueCount,
+      V_ack: acknowledgedCount,
+      V_open: issueCount - acknowledgedCount
+    };
+  }
+
+  // src/core/roundtrip/apply-auto-fix.ts
+  function pickNodeName(issue, resolved) {
+    if (resolved && typeof resolved.name === "string" && resolved.name.length > 0) {
+      return resolved.name;
+    }
+    if (typeof issue.nodePath === "string" && issue.nodePath.length > 0) {
+      const segments = issue.nodePath.split(/\s*[›>/]\s*/);
+      const tail = segments[segments.length - 1];
+      if (tail && tail.length > 0) return tail;
+    }
+    return issue.nodeId;
+  }
+  function mapInstanceFallbackIcon(result) {
+    if (result.icon === "\u2705") return "\u{1F527}";
+    return result.icon;
+  }
+  async function applyAutoFix(issue, context) {
+    const { categories } = context;
+    const ruleId = issue.ruleId;
+    if (issue.targetProperty === "name" && typeof issue.suggestedName === "string") {
+      const suggestedName = issue.suggestedName;
+      const question = {
+        nodeId: issue.nodeId,
+        ruleId,
+        ...issue.sourceChildId ? { sourceChildId: issue.sourceChildId } : {}
+      };
+      const result = await applyWithInstanceFallback(
+        question,
+        (target) => {
+          if (target) {
+            target.name = suggestedName;
+          }
+        },
+        {
+          categories,
+          ...context.allowDefinitionWrite !== void 0 ? { allowDefinitionWrite: context.allowDefinitionWrite } : {},
+          ...context.telemetry !== void 0 ? { telemetry: context.telemetry } : {}
+        }
+      );
+      const sceneAfter = await figma.getNodeByIdAsync(issue.nodeId);
+      return {
+        outcome: mapInstanceFallbackIcon(result),
+        nodeId: issue.nodeId,
+        nodeName: pickNodeName(issue, sceneAfter),
+        ruleId,
+        label: result.label
+      };
+    }
+    const scene = await figma.getNodeByIdAsync(issue.nodeId);
+    const markdown = issue.message ?? `Auto-flagged: ${ruleId}`;
+    if (scene) {
+      upsertCanicodeAnnotation(scene, {
+        ruleId,
+        markdown,
+        categoryId: categories.flag,
+        ...issue.annotationProperties && issue.annotationProperties.length > 0 ? { properties: issue.annotationProperties } : {}
+      });
+    }
+    return {
+      outcome: "\u{1F4DD}",
+      nodeId: issue.nodeId,
+      nodeName: pickNodeName(issue, scene),
+      ruleId,
+      label: scene ? `annotation added to canicode:flag \u2014 ${ruleId}` : `missing node (annotation skipped) \u2014 ${ruleId}`
+    };
+  }
+  async function applyAutoFixes(issues, context) {
+    const out = [];
+    for (const issue of issues) {
+      if (issue.applyStrategy !== "auto-fix") {
+        out.push({
+          outcome: "\u23ED\uFE0F",
+          nodeId: issue.nodeId,
+          nodeName: pickNodeName(issue, null),
+          ruleId: issue.ruleId,
+          label: `skipped \u2014 applyStrategy is ${issue.applyStrategy ?? "absent"}`
+        });
+        continue;
+      }
+      out.push(await applyAutoFix(issue, context));
+    }
+    return out;
+  }
+
+  // src/core/roundtrip/remove-canicode-annotations.ts
+  var LEGACY_CANICODE_PREFIX = "**[canicode]";
+  function isCanicodeAnnotation(annotation, categories) {
+    const canicodeIds = new Set(
+      [
+        categories.gotcha,
+        categories.flag,
+        categories.fallback,
+        categories.legacyAutoFix
+      ].filter((id) => Boolean(id))
+    );
+    if (annotation.categoryId && canicodeIds.has(annotation.categoryId)) {
+      return true;
+    }
+    if (annotation.labelMarkdown?.startsWith(LEGACY_CANICODE_PREFIX)) {
+      return true;
+    }
+    return false;
+  }
+  function removeCanicodeAnnotations(annotations, categories) {
+    return annotations.filter((a) => !isCanicodeAnnotation(a, categories));
+  }
 
+  exports.applyAutoFix = applyAutoFix;
+  exports.applyAutoFixes = applyAutoFixes;
   exports.applyPropertyMod = applyPropertyMod;
   exports.applyWithInstanceFallback = applyWithInstanceFallback;
+  exports.computeRoundtripTally = computeRoundtripTally;
   exports.ensureCanicodeCategories = ensureCanicodeCategories;
+  exports.extractAcknowledgmentsFromNode = extractAcknowledgmentsFromNode;
+  exports.isCanicodeAnnotation = isCanicodeAnnotation;
   exports.probeDefinitionWritability = probeDefinitionWritability;
+  exports.readCanicodeAcknowledgments = readCanicodeAcknowledgments;
+  exports.removeCanicodeAnnotations = removeCanicodeAnnotations;
   exports.resolveVariableByName = resolveVariableByName;
   exports.stripAnnotations = stripAnnotations;
   exports.upsertCanicodeAnnotation = upsertCanicodeAnnotation;