canicode 0.9.1 → 0.10.1

package/dist/index.js

@@ -6,7 +6,7 @@ import 'crypto';
 import { homedir } from 'os';
 
 // package.json
-var version = "0.9.1";
+var version = "0.10.1";
 var SeveritySchema = z.enum([
   "blocking",
   "risk",
@@ -274,6 +274,92 @@ var VisualCompareCliOptionsSchema = z.object({
   figmaScale: figmaScaleNumber.optional(),
   expandRoot: z.boolean().optional()
 });
+var GradeSchema = z.enum(["S", "A+", "A", "B+", "B", "C+", "C", "D", "F"]);
+var CategoryScoreResultSchema = z.object({
+  category: CategorySchema,
+  score: z.number(),
+  maxScore: z.number(),
+  percentage: z.number(),
+  issueCount: z.number().int().min(0),
+  uniqueRuleCount: z.number().int().min(0),
+  weightedIssueCount: z.number(),
+  densityScore: z.number(),
+  diversityScore: z.number(),
+  bySeverity: z.object({
+    blocking: z.number().int().min(0),
+    risk: z.number().int().min(0),
+    "missing-info": z.number().int().min(0),
+    suggestion: z.number().int().min(0)
+  })
+});
+var McpIssueSchema = z.object({
+  ruleId: z.string(),
+  subType: z.string().optional(),
+  severity: SeveritySchema,
+  nodeId: z.string(),
+  nodePath: z.string(),
+  message: z.string()
+});
+var McpAnalyzeResponseSchema = z.object({
+  version: z.string(),
+  analyzedAt: z.string(),
+  fileKey: z.string().optional(),
+  fileName: z.string(),
+  nodeCount: z.number().int().min(0),
+  maxDepth: z.number().int().min(0),
+  issueCount: z.number().int().min(0),
+  isReadyForCodeGen: z.boolean(),
+  blockingIssueCount: z.number().int().min(0),
+  scores: z.object({
+    overall: z.object({
+      score: z.number(),
+      maxScore: z.number(),
+      percentage: z.number(),
+      grade: GradeSchema
+    }),
+    categories: z.record(CategorySchema, CategoryScoreResultSchema)
+  }),
+  issuesByRule: z.record(z.string(), z.number().int().min(0)),
+  issues: z.array(McpIssueSchema),
+  summary: z.string(),
+  failedRules: z.array(z.string()).optional()
+});
+var GradeSchema2 = z.enum(["S", "A+", "A", "B+", "B", "C+", "C", "D", "F"]);
+var InstanceContextSchema = z.object({
+  parentInstanceNodeId: z.string(),
+  sourceNodeId: z.string(),
+  sourceComponentId: z.string().optional(),
+  sourceComponentName: z.string().optional()
+});
+var RuleApplyStrategySchema = z.enum([
+  "property-mod",
+  "structural-mod",
+  "annotation",
+  "auto-fix"
+]);
+var TargetPropertySchema = z.union([z.string(), z.array(z.string())]);
+var AnnotationPropertySchema = z.object({ type: z.string() });
+var GotchaSurveyQuestionSchema = z.object({
+  nodeId: z.string(),
+  nodeName: z.string(),
+  ruleId: z.string(),
+  severity: SeveritySchema,
+  question: z.string(),
+  hint: z.string(),
+  example: z.string(),
+  instanceContext: InstanceContextSchema.optional(),
+  applyStrategy: RuleApplyStrategySchema,
+  targetProperty: TargetPropertySchema.optional(),
+  annotationProperties: z.array(AnnotationPropertySchema).optional(),
+  suggestedName: z.string().optional(),
+  isInstanceChild: z.boolean(),
+  sourceChildId: z.string().optional()
+});
+var GotchaSurveySchema = z.object({
+  designGrade: GradeSchema2,
+  isReadyForCodeGen: z.boolean(),
+  questions: z.array(GotchaSurveyQuestionSchema)
+});
 
 // src/core/rules/rule-config.ts
 var RULE_ID_CATEGORY = {
@@ -451,6 +537,44 @@ function getConfigsWithPreset(preset) {
   }
   return configs;
 }
+var RULE_ANNOTATION_PROPERTIES = {
+  "missing-size-constraint": {
+    default: [{ type: "width" }, { type: "height" }]
+  },
+  "irregular-spacing": {
+    bySubType: {
+      gap: [{ type: "itemSpacing" }],
+      padding: [{ type: "padding" }]
+    }
+  },
+  "fixed-size-in-auto-layout": {
+    default: [{ type: "width" }, { type: "height" }, { type: "layoutMode" }]
+  },
+  "raw-value": {
+    bySubType: {
+      color: [{ type: "fills" }],
+      font: [
+        { type: "fontSize" },
+        { type: "fontFamily" },
+        { type: "fontWeight" },
+        { type: "lineHeight" }
+      ],
+      spacing: [{ type: "itemSpacing" }, { type: "padding" }]
+    }
+  },
+  "absolute-position-in-auto-layout": {
+    default: [{ type: "layoutMode" }]
+  }
+};
+function getAnnotationProperties(ruleId, subType) {
+  const entry = RULE_ANNOTATION_PROPERTIES[ruleId];
+  if (!entry) return void 0;
+  if (subType !== void 0 && entry.bySubType) {
+    const match = entry.bySubType[subType];
+    if (match) return match;
+  }
+  return entry.default;
+}
 function getRuleOption(ruleId, optionKey, defaultValue) {
   const config = RULE_CONFIGS[ruleId];
   if (!config.options) return defaultValue;
@@ -714,6 +838,95 @@ function analyzeFile(file, options) {
   return engine.analyze(file);
 }
 
+// src/core/adapters/instance-id-parser.ts
+function isInstanceChildNodeId(nodeId) {
+  return nodeId.startsWith("I") && nodeId.includes(";");
+}
+function parseInstanceChildNodeId(nodeId) {
+  if (!isInstanceChildNodeId(nodeId)) return null;
+  const segments = nodeId.split(";");
+  if (segments.length < 2) return null;
+  const parentInstanceId = segments[0].replace(/^I/, "");
+  const sourceNodeId = segments[segments.length - 1];
+  if (!parentInstanceId || !sourceNodeId) return null;
+  return { parentInstanceId, sourceNodeId };
+}
+
+// src/core/gotcha/apply-context.ts
+var STRATEGY_BY_RULE = {
+  // Strategy A — property modification
+  "no-auto-layout": "property-mod",
+  "fixed-size-in-auto-layout": "property-mod",
+  "missing-size-constraint": "property-mod",
+  "irregular-spacing": "property-mod",
+  "non-semantic-name": "property-mod",
+  // Strategy B — structural modification (needs user confirmation)
+  "non-layout-container": "structural-mod",
+  "deep-nesting": "structural-mod",
+  "missing-component": "structural-mod",
+  "detached-instance": "structural-mod",
+  // Strategy C — annotation only
+  "absolute-position-in-auto-layout": "annotation",
+  "variant-structure-mismatch": "annotation",
+  // Strategy D — auto-fix lower-severity issues from analyze output
+  "non-standard-naming": "auto-fix",
+  "inconsistent-naming-convention": "auto-fix",
+  "raw-value": "auto-fix",
+  "missing-interaction-state": "auto-fix",
+  "missing-prototype": "auto-fix"
+};
+function resolveTargetProperty(ruleId, subType) {
+  switch (ruleId) {
+    case "no-auto-layout":
+      return ["layoutMode", "itemSpacing"];
+    case "fixed-size-in-auto-layout":
+      if (subType === "horizontal") return "layoutSizingHorizontal";
+      return ["layoutSizingHorizontal", "layoutSizingVertical"];
+    case "missing-size-constraint":
+      if (subType === "wrap") return "minWidth";
+      if (subType === "max-width") return "maxWidth";
+      return ["minWidth", "maxWidth"];
+    case "irregular-spacing":
+      if (subType === "gap") return "itemSpacing";
+      return ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft"];
+    case "non-semantic-name":
+      return "name";
+    case "non-layout-container":
+      return "layoutMode";
+    case "non-standard-naming":
+    case "inconsistent-naming-convention":
+      return "name";
+    case "deep-nesting":
+    case "missing-component":
+    case "detached-instance":
+    case "absolute-position-in-auto-layout":
+    case "variant-structure-mismatch":
+    case "raw-value":
+    case "missing-interaction-state":
+    case "missing-prototype":
+      return void 0;
+  }
+}
+function computeApplyContext(violation, instanceContext) {
+  const ruleId = violation.ruleId;
+  const applyStrategy = STRATEGY_BY_RULE[ruleId] ?? "annotation";
+  const targetProperty = resolveTargetProperty(ruleId, violation.subType);
+  const annotationProperties = getAnnotationProperties(
+    ruleId,
+    violation.subType
+  );
+  const parsed = parseInstanceChildNodeId(violation.nodeId);
+  const isInstanceChild = parsed !== null || isInstanceChildNodeId(violation.nodeId);
+  const sourceChildId = parsed?.sourceNodeId;
+  return {
+    applyStrategy,
+    ...targetProperty !== void 0 ? { targetProperty } : {},
+    ...annotationProperties !== void 0 ? { annotationProperties } : {},
+    isInstanceChild,
+    ...sourceChildId !== void 0 ? { sourceChildId } : {}
+  };
+}
+
 // src/core/engine/scoring.ts
 function computeTotalScorePerCategory(configs) {
   const totals = Object.fromEntries(
@@ -741,6 +954,9 @@ function calculateGrade(percentage) {
   if (percentage >= 50) return "D";
   return "F";
 }
+function isReadyForCodeGen(grade) {
+  return grade === "S" || grade === "A+" || grade === "A";
+}
 function gradeToClassName(grade) {
   return grade.replace("+", "plus");
 }
@@ -903,14 +1119,24 @@ function buildResultJson(fileName, result, scores, options) {
     const id = issue.violation.ruleId;
     issuesByRule[id] = (issuesByRule[id] ?? 0) + 1;
   }
-  const issues = result.issues.map((issue) => ({
-    ruleId: issue.violation.ruleId,
-    ...issue.violation.subType && { subType: issue.violation.subType },
-    severity: issue.config.severity,
-    nodeId: issue.violation.nodeId,
-    nodePath: issue.violation.nodePath,
-    message: issue.violation.message
-  }));
+  const issues = result.issues.map((issue) => {
+    const applyContext = computeApplyContext(issue.violation);
+    const suggestedName = issue.violation.suggestedName;
+    return {
+      ruleId: issue.violation.ruleId,
+      ...issue.violation.subType && { subType: issue.violation.subType },
+      severity: issue.config.severity,
+      nodeId: issue.violation.nodeId,
+      nodePath: issue.violation.nodePath,
+      message: issue.violation.message,
+      applyStrategy: applyContext.applyStrategy,
+      ...applyContext.targetProperty !== void 0 ? { targetProperty: applyContext.targetProperty } : {},
+      ...applyContext.annotationProperties !== void 0 ? { annotationProperties: applyContext.annotationProperties } : {},
+      ...suggestedName !== void 0 ? { suggestedName } : {},
+      isInstanceChild: applyContext.isInstanceChild,
+      ...applyContext.sourceChildId !== void 0 ? { sourceChildId: applyContext.sourceChildId } : {}
+    };
+  });
   const json = {
     version,
     analyzedAt: result.analyzedAt,
@@ -919,6 +1145,8 @@ function buildResultJson(fileName, result, scores, options) {
     nodeCount: result.nodeCount,
     maxDepth: result.maxDepth,
     issueCount: result.issues.length,
+    isReadyForCodeGen: isReadyForCodeGen(scores.overall.grade),
+    blockingIssueCount: scores.summary.blocking,
     scores: {
       overall: scores.overall,
       categories: scores.byCategory
@@ -1698,6 +1926,36 @@ function tokenDeltaToDifficulty(baselineTokens, strippedTokens) {
   return "failed";
 }
 
+// src/core/gotcha/resolve-apply-target.ts
+function resolveGotchaApplyTarget(nodeId, instanceContext) {
+  if (instanceContext) {
+    const componentPhrase = instanceContext.sourceComponentName ? `inside component ${instanceContext.sourceComponentName}` : "inside the source component";
+    return {
+      sceneNodeId: nodeId,
+      definitionNodeId: instanceContext.sourceNodeId,
+      strategy: "prefer-definition",
+      optIn: { preferDefinitionForLayoutProps: true },
+      guidance: `This question targets a node inside an instance. Overrides may fail on the scene node. For layout and min/max sizing, apply changes on node ${instanceContext.sourceNodeId} ${componentPhrase} (parent instance ${instanceContext.parentInstanceNodeId}). Confirm with the user first \u2014 definition edits propagate to every instance of that component in the file.`
+    };
+  }
+  if (isInstanceChildNodeId(nodeId)) {
+    return {
+      sceneNodeId: nodeId,
+      definitionNodeId: void 0,
+      strategy: "definition-unknown",
+      optIn: { preferDefinitionForLayoutProps: true },
+      guidance: "The node id looks like a Figma instance child (`I...;...`) but no `instanceContext` was attached. Parse the segment after the last `;` as the source definition id, resolve the parent INSTANCE, and use `getMainComponentAsync()` when `figma.getNodeById(sourceId)` is not enough (e.g. nested instances)."
+    };
+  }
+  return {
+    sceneNodeId: nodeId,
+    definitionNodeId: void 0,
+    strategy: "scene-only",
+    optIn: { preferDefinitionForLayoutProps: false },
+    guidance: ""
+  };
+}
+
 // src/core/rules/node-semantics.ts
 function isContainerNode(node) {
   return node.type === "FRAME" || node.type === "GROUP" || node.type === "COMPONENT" || node.type === "INSTANCE";
@@ -2678,6 +2936,10 @@ var variantStructureMismatch = defineRule({
 });
 
 // src/core/rules/naming/index.ts
+function capitalize(s) {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
 function detectNamingConvention(name) {
   if (/^[a-z]+(-[a-z]+)*$/.test(name)) return "kebab-case";
   if (/^[a-z]+(_[a-z]+)*$/.test(name)) return "snake_case";
@@ -2803,6 +3065,7 @@ var inconsistentNamingConventionCheck = (node, context) => {
       ruleId: inconsistentNamingConventionDef.id,
       nodeId: node.id,
       nodePath: context.path.join(" > "),
+      suggestedName: suggested,
       ...inconsistentNamingMsg(node.name, nodeConvention, dominantConvention, suggested)
     };
   }
@@ -2840,6 +3103,7 @@ var nonStandardNamingCheck = (node, context) => {
             subType: "state-name",
             nodeId: node.id,
             nodePath: context.path.join(" > "),
+            suggestedName: capitalize(suggestion),
             ...nonStandardNamingMsg.stateName(node.name, opt, suggestion)
           };
         }
@@ -4572,7 +4836,7 @@ async function loadFromApi(fileKey, nodeId, token) {
   return { file, nodeId };
 }
 
-// src/agents/orchestrator.ts
+// src/agents/calibration-compute.ts
 function normalizeActualImpact(impact) {
   const mapping = {
     none: "easy",
@@ -4782,6 +5046,6 @@ var ActivityLogger = class {
   }
 };
 
-export { ALL_STRIP_TYPES, ActivityLogger, AnalysisFileSchema, AnalysisNodeSchema, AnalysisNodeTypeSchema, CATEGORIES, CATEGORY_LABELS, CalibrationConfigSchema, CalibrationStatusSchema, CategorySchema, CategoryScoreSchema, ConfidenceSchema, ConversionRecordSchema, DEPTH_WEIGHT_CATEGORIES, DESIGN_TREE_INFO_TYPES, DifficultySchema, FigmaClient, FigmaClientError, FigmaFileLoadError, FigmaUrlInfoSchema, FigmaUrlParseError, GapAnalyzerOutputSchema, GapEntrySchema, GridChildAlignSchema, IssueSchema, LayoutAlignSchema, LayoutConstraintSchema, LayoutModeSchema, LayoutPositioningSchema, LayoutWrapSchema, MismatchCaseSchema, MismatchTypeSchema, NewRuleProposalSchema, NodeIssueSummarySchema, OverflowDirectionSchema, RULE_CONFIGS, RULE_ID_CATEGORY, ReportMetadataSchema, ReportSchema, RuleConfigSchema, RuleDefinitionSchema, RuleEngine, RuleImpactAssessmentSchema, RuleRelatedStruggleSchema, SEVERITY_LABELS, SEVERITY_WEIGHT, SamplingStrategySchema, ScoreAdjustmentSchema, SeveritySchema, StripDeltaResultSchema, StripDeltasArraySchema, StripTypeEnum, UncoveredStruggleSchema, UncoveredStrugglesInputSchema, version as VERSION, VisualCompareCliOptionsSchema, absolutePositionInAutoLayout, analyzeFile, buildFigmaDeepLink, buildResultJson, calculateScores, collectComponentIds, collectInteractionDestinationIds, createRuleEngine, deepNesting, defineRule, detachedInstance, extractRuleScores, fixedSizeInAutoLayout, formatScoreSummary, generateCalibrationReport, generateDesignTree, generateDesignTreeWithStats, getAnalysisState, getCategoryLabel, getConfigsWithPreset, getRuleOption, getSeverityLabel, gradeToClassName, inconsistentNamingConvention, irregularSpacing, loadFigmaFileFromJson, missingComponent, missingInteractionState, missingPrototype, missingSizeConstraint, noAutoLayout, nonLayoutContainer, nonSemanticName, nonStandardNaming, parseFigmaJson, parseFigmaUrl, rawValue, resolveComponentDefinitions, resolveInteractionDestinations, ruleRegistry, runAnalysisAgent, runCalibrationAnalyze, runCalibrationEvaluate, runEvaluationAgent, runTuningAgent, stripDeltaToDifficulty, stripDesignTree, supportsDepthWeight, toCommentableNodeId, tokenDeltaToDifficulty, transformComponentMasterNodes, transformFigmaResponse, transformFileNodesResponse, variantStructureMismatch };
+export { ALL_STRIP_TYPES, ActivityLogger, AnalysisFileSchema, AnalysisNodeSchema, AnalysisNodeTypeSchema, AnnotationPropertySchema, CATEGORIES, CATEGORY_LABELS, CalibrationConfigSchema, CalibrationStatusSchema, CategorySchema, CategoryScoreSchema, ConfidenceSchema, ConversionRecordSchema, DEPTH_WEIGHT_CATEGORIES, DESIGN_TREE_INFO_TYPES, DifficultySchema, FigmaClient, FigmaClientError, FigmaFileLoadError, FigmaUrlInfoSchema, FigmaUrlParseError, GapAnalyzerOutputSchema, GapEntrySchema, GotchaSurveyQuestionSchema, GotchaSurveySchema, GridChildAlignSchema, InstanceContextSchema, IssueSchema, LayoutAlignSchema, LayoutConstraintSchema, LayoutModeSchema, LayoutPositioningSchema, LayoutWrapSchema, McpAnalyzeResponseSchema, MismatchCaseSchema, MismatchTypeSchema, NewRuleProposalSchema, NodeIssueSummarySchema, OverflowDirectionSchema, RULE_ANNOTATION_PROPERTIES, RULE_CONFIGS, RULE_ID_CATEGORY, ReportMetadataSchema, ReportSchema, RuleApplyStrategySchema, RuleConfigSchema, RuleDefinitionSchema, RuleEngine, RuleImpactAssessmentSchema, RuleRelatedStruggleSchema, SEVERITY_LABELS, SEVERITY_WEIGHT, SamplingStrategySchema, ScoreAdjustmentSchema, SeveritySchema, StripDeltaResultSchema, StripDeltasArraySchema, StripTypeEnum, UncoveredStruggleSchema, UncoveredStrugglesInputSchema, version as VERSION, VisualCompareCliOptionsSchema, absolutePositionInAutoLayout, analyzeFile, buildFigmaDeepLink, buildResultJson, calculateScores, collectComponentIds, collectInteractionDestinationIds, createRuleEngine, deepNesting, defineRule, detachedInstance, extractRuleScores, fixedSizeInAutoLayout, formatScoreSummary, generateCalibrationReport, generateDesignTree, generateDesignTreeWithStats, getAnalysisState, getAnnotationProperties, getCategoryLabel, getConfigsWithPreset, getRuleOption, getSeverityLabel, gradeToClassName, inconsistentNamingConvention, irregularSpacing, isInstanceChildNodeId, isReadyForCodeGen, loadFigmaFileFromJson, missingComponent, missingInteractionState, missingPrototype, missingSizeConstraint, noAutoLayout, nonLayoutContainer, nonSemanticName, nonStandardNaming, parseFigmaJson, parseFigmaUrl, parseInstanceChildNodeId, rawValue, resolveComponentDefinitions, resolveGotchaApplyTarget, resolveInteractionDestinations, ruleRegistry, runAnalysisAgent, runCalibrationAnalyze, runCalibrationEvaluate, runEvaluationAgent, runTuningAgent, stripDeltaToDifficulty, stripDesignTree, supportsDepthWeight, toCommentableNodeId, tokenDeltaToDifficulty, transformComponentMasterNodes, transformFigmaResponse, transformFileNodesResponse, variantStructureMismatch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map