ppt-template-reuse 0.4.0-rc.2

package/src/core/template-intelligence.mjs

@@ -0,0 +1,675 @@
+#!/usr/bin/env node
+
+import crypto from "node:crypto";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  exists,
+  parseArgs,
+  readJson,
+  requireArg,
+  writeJson,
+} from "./planner-lib.mjs";
+
+const USE_CASE_SIGNALS = {
+  "academic-defense": [
+    /论文|研究|答辩|课题|文献|方法|假设|实验|结论|参考文献|thesis|research|methodology|hypothesis/i,
+  ],
+  "course-presentation": [
+    /课程|作业|课堂|汇报|小组|姓名|学号|指导教师|course|homework|class|assignment/i,
+  ],
+  "legal-analysis": [
+    /法律|民法|刑法|案例|法院|法条|争点|请求权|规范|判决|law|legal|court|case/i,
+  ],
+  "teaching-training": [
+    /教学|培训|学习目标|知识点|练习|课程目标|课堂互动|training|lesson|learning objective/i,
+  ],
+  "business-pitch": [
+    /融资|商业模式|市场规模|竞争优势|投资|团队|痛点|解决方案|pitch|market|investor|business model/i,
+  ],
+  "product-proposal": [
+    /产品|用户|功能|方案|路线图|里程碑|需求|体验|product|feature|roadmap|solution/i,
+  ],
+  "corporate-report": [
+    /年度|季度|业绩|工作总结|经营|指标|部门|计划|复盘|annual|quarter|performance|department/i,
+  ],
+  "data-report": [
+    /数据|指标|统计|趋势|同比|环比|样本|调查|分析结果|data|metric|trend|survey|analysis/i,
+  ],
+  "policy-public-affairs": [
+    /政策|治理|公共|监管|制度|改革|社会|政府|policy|governance|regulation|public/i,
+  ],
+  "visual-portfolio": [
+    /作品集|摄影|案例展示|品牌|视觉|设计|portfolio|gallery|photography|brand/i,
+  ],
+};
+
+const USE_CASE_REQUIRED_CAPABILITIES = {
+  "academic-defense": ["cover", "roadmap", "analysis", "evidence", "conclusion"],
+  "course-presentation": ["cover", "roadmap", "analysis", "conclusion"],
+  "legal-analysis": ["cover", "issue", "analysis", "counterargument", "conclusion"],
+  "teaching-training": ["cover", "roadmap", "process", "summary"],
+  "business-pitch": ["cover", "problem", "solution", "evidence", "closing"],
+  "product-proposal": ["cover", "problem", "process", "comparison", "closing"],
+  "corporate-report": ["cover", "roadmap", "evidence", "summary"],
+  "data-report": ["cover", "evidence", "comparison", "summary"],
+  "policy-public-affairs": ["cover", "background", "analysis", "recommendation"],
+  "visual-portfolio": ["cover", "image-evidence", "closing"],
+  "general-report": ["cover", "roadmap", "analysis", "summary"],
+};
+
+const FAMILY_FUNCTIONS = {
+  cover: ["opening", "identify-topic"],
+  agenda: ["roadmap", "preview-structure"],
+  divider: ["section", "signal-transition"],
+  timeline: ["chronology", "show-change"],
+  process: ["explain-process", "show-sequence"],
+  comparison: ["compare", "evaluate-options"],
+  table: ["organize-evidence", "compare"],
+  chart: ["quantify", "show-trend"],
+  "image-led": ["image-evidence", "case-example"],
+  image: ["image-evidence", "case-example"],
+  metric: ["quantify", "highlight-metric"],
+  "three-column": ["parallel-reasons", "compare-categories"],
+  "four-column": ["parallel-reasons", "compare-categories"],
+  "multi-column": ["parallel-reasons", "compare-categories"],
+  "two-column": ["compare", "claim-and-evidence"],
+  matrix: ["compare", "evaluate-options"],
+  statement: ["claim", "highlight-conclusion"],
+  quote: ["quote", "support-claim"],
+  "case-study": ["case-example", "claim-and-evidence"],
+  team: ["introduce-people", "establish-credibility"],
+  reference: ["reference", "source-ledger"],
+  references: ["reference", "source-ledger"],
+  closing: ["closing", "call-to-action"],
+  summary: ["summary", "synthesize"],
+  "text-content": ["analysis", "explain"],
+};
+
+const FUNCTION_CAPABILITY_ALIASES = {
+  opening: "cover",
+  roadmap: "roadmap",
+  chronology: "timeline",
+  "show-change": "timeline",
+  "explain-process": "process",
+  compare: "comparison",
+  "evaluate-options": "comparison",
+  "organize-evidence": "evidence",
+  quantify: "evidence",
+  "show-trend": "evidence",
+  "image-evidence": "image-evidence",
+  "highlight-metric": "evidence",
+  "parallel-reasons": "analysis",
+  "claim-and-evidence": "analysis",
+  analysis: "analysis",
+  claim: "analysis",
+  "highlight-conclusion": "summary",
+  explain: "analysis",
+  "support-claim": "evidence",
+  "case-example": "evidence",
+  "introduce-people": "team",
+  "establish-credibility": "team",
+  summary: "summary",
+  synthesize: "summary",
+  closing: "closing",
+  reference: "reference",
+};
+
+function stableObject(value) {
+  if (Array.isArray(value)) return value.map(stableObject);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.keys(value)
+        .sort()
+        .map((key) => [key, stableObject(value[key])]),
+    );
+  }
+  return value;
+}
+
+function fingerprint(value) {
+  return crypto
+    .createHash("sha256")
+    .update(JSON.stringify(stableObject(value)))
+    .digest("hex");
+}
+
+function normalized(value) {
+  return String(value || "").trim().toLowerCase();
+}
+
+function recipeText(recipe) {
+  return (recipe.slots || [])
+    .map((slot) => String(slot.originalText || ""))
+    .filter(Boolean)
+    .join(" ");
+}
+
+function effectiveRecipe(recipe, correction = {}) {
+  const next = structuredClone(recipe);
+  for (const key of [
+    "layoutFamily",
+    "layoutVariant",
+    "narrativeRole",
+    "confidence",
+    "autoUseStatus",
+    "approvedForAutoUse",
+    "excludedFromAutoUse",
+    "exclusionReason",
+  ]) {
+    if (correction[key] !== undefined) next[key] = correction[key];
+  }
+  if (correction.slots) {
+    next.slots = (next.slots || []).map((slot) => ({
+      ...slot,
+      ...(correction.slots[slot.slotId] || {}),
+    }));
+  }
+  if (Array.isArray(correction.protectedElementIds)) {
+    next.protectedElementIds = correction.protectedElementIds;
+  }
+  return next;
+}
+
+function slotStats(recipe) {
+  const slots = recipe.slots || [];
+  const byType = {};
+  const byPurpose = {};
+  const bySemantic = {};
+  for (const slot of slots) {
+    const type = normalized(slot.type || "unknown");
+    const purpose = normalized(slot.purpose || "unknown");
+    const semantic = normalized(slot.semanticType || slot.type || "unknown");
+    byType[type] = Number(byType[type] || 0) + 1;
+    byPurpose[purpose] = Number(byPurpose[purpose] || 0) + 1;
+    bySemantic[semantic] = Number(bySemantic[semantic] || 0) + 1;
+  }
+  return { total: slots.length, byType, byPurpose, bySemantic };
+}
+
+function communicationFunctions(recipe) {
+  const family = normalized(recipe.layoutFamily);
+  const role = normalized(recipe.narrativeRole);
+  const functions = new Set(FAMILY_FUNCTIONS[family] || []);
+  if (role) functions.add(role);
+  if (/时间|日期|阶段|年|月|timeline|milestone/i.test(recipeText(recipe))) {
+    functions.add("chronology");
+  }
+  if (/对比|比较|优势|不足|vs\.?|compare/i.test(recipeText(recipe))) {
+    functions.add("compare");
+  }
+  if (/结论|总结|建议|conclusion|summary/i.test(recipeText(recipe))) {
+    functions.add("summary");
+  }
+  return [...functions].sort();
+}
+
+function inferContentRecipe(recipe, stats, functions) {
+  const bodySlots = Number(stats.byPurpose.body || 0);
+  const labelSlots = Number(stats.byPurpose.label || 0);
+  const imageSlots = Number(stats.byType.image || 0);
+  const tableSlots = Number(stats.byType.table || 0);
+  const chartSlots = Number(stats.byType.chart || 0);
+  const itemSlots = Math.max(bodySlots, labelSlots);
+  const parts = ["title"];
+  if (itemSlots) parts.push(`${itemSlots} parallel text item${itemSlots > 1 ? "s" : ""}`);
+  if (imageSlots) parts.push(`${imageSlots} image${imageSlots > 1 ? "s" : ""}`);
+  if (tableSlots) parts.push(`${tableSlots} fixed table${tableSlots > 1 ? "s" : ""}`);
+  if (chartSlots) parts.push(`${chartSlots} native chart${chartSlots > 1 ? "s" : ""}`);
+  return {
+    pattern: parts.join(" + "),
+    functions,
+    recommendedSourceUnits: {
+      min: Math.max(1, itemSlots || 1),
+      max: Math.max(1, Math.min(7, itemSlots ? itemSlots * 2 : 3)),
+    },
+    onePrimaryClaim: !["cover", "agenda", "divider", "closing"].includes(
+      normalized(recipe.layoutFamily),
+    ),
+  };
+}
+
+function inferTemplateKind(recipes, manifest) {
+  const totalSlots = recipes.reduce((sum, recipe) => sum + (recipe.slots || []).length, 0);
+  const sampleSlots = recipes.reduce(
+    (sum, recipe) =>
+      sum +
+      (recipe.slots || []).filter(
+        (slot) => normalized(slot.semanticType) === "sample-content",
+      ).length,
+    0,
+  );
+  const instructionSlots = recipes.reduce(
+    (sum, recipe) =>
+      sum +
+      (recipe.slots || []).filter((slot) =>
+        /请输入|请在此|点击添加|插入图片|replace|type here|add title/i.test(
+          String(slot.originalText || ""),
+        ),
+      ).length,
+    0,
+  );
+  const mediaCount = Number(manifest?.packageParts?.mediaCount || 0);
+  const slideCount = Math.max(1, recipes.length);
+  const editableSlideRatio =
+    recipes.filter((recipe) => (recipe.slots || []).length > 0).length / slideCount;
+  const familyCount = new Set(recipes.map((recipe) => recipe.layoutFamily)).size;
+  const galleryRatio = familyCount / slideCount;
+  const sampleRatio = totalSlots ? sampleSlots / totalSlots : 0;
+  const instructionRatio = totalSlots ? instructionSlots / totalSlots : 0;
+
+  if (editableSlideRatio < 0.2 && mediaCount >= slideCount * 0.8) {
+    return { kind: "flattened-deck", confidence: 0.92 };
+  }
+  if (galleryRatio >= 0.4 && slideCount >= 10) {
+    return { kind: "layout-gallery", confidence: 0.84 };
+  }
+  if (sampleRatio >= 0.12 && instructionRatio >= 0.08) {
+    return { kind: "hybrid-template", confidence: 0.82 };
+  }
+  if (instructionRatio >= 0.12) {
+    return { kind: "blank-template", confidence: 0.8 };
+  }
+  if (sampleRatio >= 0.12) {
+    return { kind: "filled-example", confidence: 0.78 };
+  }
+  return { kind: "narrative-deck", confidence: 0.68 };
+}
+
+function inferPurposeProfile(recipes) {
+  const text = recipes.map(recipeText).join(" ");
+  const rawScores = {};
+  for (const [useCase, patterns] of Object.entries(USE_CASE_SIGNALS)) {
+    rawScores[useCase] = patterns.reduce((sum, pattern) => {
+      const matches = text.match(new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`));
+      return sum + (matches?.length || 0);
+    }, 0);
+  }
+
+  const families = new Set(recipes.map((recipe) => normalized(recipe.layoutFamily)));
+  if (families.has("reference") || families.has("references")) {
+    rawScores["academic-defense"] = Number(rawScores["academic-defense"] || 0) + 2;
+    rawScores["legal-analysis"] = Number(rawScores["legal-analysis"] || 0) + 1;
+  }
+  if (families.has("chart") || families.has("table")) {
+    rawScores["data-report"] = Number(rawScores["data-report"] || 0) + 2;
+    rawScores["corporate-report"] = Number(rawScores["corporate-report"] || 0) + 1;
+  }
+  if (families.has("image-led")) {
+    rawScores["visual-portfolio"] = Number(rawScores["visual-portfolio"] || 0) + 2;
+  }
+  const ranked = Object.entries(rawScores)
+    .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+  const maximum = ranked[0]?.[1] || 0;
+  const primary = maximum
+    ? ranked.filter(([, score]) => score === maximum).slice(0, 2).map(([name]) => name)
+    : ["general-report"];
+  const secondary = ranked
+    .filter(([, score]) => score > 0 && score < maximum)
+    .slice(0, 3)
+    .map(([name]) => name);
+  const confidence = maximum
+    ? Math.min(0.95, 0.55 + maximum / Math.max(10, recipes.length * 0.8))
+    : 0.45;
+  return {
+    primaryUseCases: primary,
+    secondaryUseCases: secondary,
+    incompatibleUseCases: [],
+    evidenceScores: rawScores,
+    confidence: Number(confidence.toFixed(3)),
+  };
+}
+
+function inferDensity(recipes) {
+  const bodyChars = recipes.map((recipe) => Number(recipe.capacity?.bodyChars || 0));
+  const averageBody =
+    bodyChars.reduce((sum, value) => sum + value, 0) / Math.max(1, bodyChars.length);
+  if (averageBody >= 260) return "high";
+  if (averageBody >= 110) return "medium";
+  return "low";
+}
+
+function inferVisualBalance(recipes) {
+  const totals = recipes.reduce(
+    (accumulator, recipe) => {
+      for (const slot of recipe.slots || []) {
+        if (slot.type === "text") accumulator.text += 1;
+        else if (["image", "chart", "table"].includes(slot.type)) accumulator.visual += 1;
+      }
+      return accumulator;
+    },
+    { text: 0, visual: 0 },
+  );
+  const ratio = totals.visual / Math.max(1, totals.text + totals.visual);
+  if (ratio >= 0.45) return "visual-led";
+  if (ratio <= 0.15) return "text-led";
+  return "mixed";
+}
+
+function capabilityInventory(slides) {
+  const capabilities = {};
+  for (const slide of slides) {
+    const tokens = new Set([
+      slide.layoutFamily,
+      ...slide.communicationFunctions.map(
+        (item) => FUNCTION_CAPABILITY_ALIASES[item] || item,
+      ),
+    ]);
+    for (const token of tokens) {
+      if (!token) continue;
+      capabilities[token] ||= {
+        count: 0,
+        safeCount: 0,
+        sourceSlides: [],
+      };
+      capabilities[token].count += 1;
+      if (slide.safetyStatus === "automatic") capabilities[token].safeCount += 1;
+      capabilities[token].sourceSlides.push(slide.sourceSlide);
+    }
+  }
+  return capabilities;
+}
+
+function applySemanticReview(profile, review) {
+  if (!review || typeof review !== "object") return profile;
+  const next = structuredClone(profile);
+  const purpose = review.purposeProfile;
+  if (purpose && typeof purpose === "object") {
+    for (const key of [
+      "primaryUseCases",
+      "secondaryUseCases",
+      "incompatibleUseCases",
+      "confidence",
+    ]) {
+      if (purpose[key] !== undefined) next.purposeProfile[key] = purpose[key];
+    }
+  }
+  const overrides = review.slides || {};
+  next.slides = next.slides.map((slide) => {
+    const override = overrides[String(slide.sourceSlide)];
+    if (!override) return slide;
+    const nextSlide = {
+      ...slide,
+      ...Object.fromEntries(
+        Object.entries(override).filter(([key]) =>
+          [
+            "layoutFamily",
+            "layoutVariant",
+            "communicationFunctions",
+            "narrativeRoles",
+            "contentRecipe",
+            "confidence",
+            "reviewNotes",
+          ].includes(key),
+        ),
+      ),
+    };
+    if (
+      override.safetyStatus &&
+      (
+        slide.safetyStatus === "automatic" ||
+        (slide.safetyStatus === "review" && override.safetyStatus === "blocked")
+      ) &&
+      ["review", "blocked"].includes(override.safetyStatus)
+    ) {
+      nextSlide.safetyStatus = override.safetyStatus;
+    }
+    return nextSlide;
+  });
+  next.capabilities = capabilityInventory(next.slides);
+  next.reviewSummary = {
+    automaticSlides: next.slides
+      .filter((slide) => slide.safetyStatus === "automatic")
+      .map((slide) => slide.sourceSlide),
+    reviewSlides: next.slides
+      .filter((slide) => slide.safetyStatus === "review")
+      .map((slide) => slide.sourceSlide),
+    blockedSlides: next.slides
+      .filter((slide) => slide.safetyStatus === "blocked")
+      .map((slide) => slide.sourceSlide),
+  };
+  next.semanticReview = {
+    applied: true,
+    reviewer: String(review.reviewer || "host-ai"),
+    reviewedAt: String(review.reviewedAt || ""),
+    reviewFingerprint: fingerprint(review),
+  };
+  return next;
+}
+
+export function assessTemplateFit(profile, brief = {}) {
+  const useCase = normalized(brief.useCase || "general-report");
+  const primary = new Set(profile.purposeProfile?.primaryUseCases || []);
+  const secondary = new Set(profile.purposeProfile?.secondaryUseCases || []);
+  const incompatible = new Set(profile.purposeProfile?.incompatibleUseCases || []);
+  const required = Array.isArray(brief.requiredCapabilities)
+    ? brief.requiredCapabilities.map(normalized)
+    : USE_CASE_REQUIRED_CAPABILITIES[useCase] || USE_CASE_REQUIRED_CAPABILITIES["general-report"];
+  const supported = required.filter(
+    (item) => Number(profile.capabilities?.[item]?.safeCount || 0) > 0,
+  );
+  const purposeScore = incompatible.has(useCase)
+    ? 0
+    : primary.has(useCase)
+      ? 1
+      : secondary.has(useCase)
+        ? 0.72
+        : useCase === "general-report"
+          ? 0.7
+          : 0.45;
+  const capabilityScore = supported.length / Math.max(1, required.length);
+  const requestedDensity = normalized(brief.density);
+  const densityScore =
+    !requestedDensity || requestedDensity === profile.densityRange ? 1 : 0.65;
+  const requestedVisual = normalized(brief.visualMode);
+  const visualScore =
+    !requestedVisual || requestedVisual === profile.visualBalance ? 1 : 0.72;
+  const editabilityScore = profile.templateKind === "flattened-deck" ? 0.35 : 1;
+  const score =
+    purposeScore * 0.4 +
+    capabilityScore * 0.25 +
+    densityScore * 0.15 +
+    visualScore * 0.1 +
+    editabilityScore * 0.1;
+  return {
+    useCase,
+    score: Number(score.toFixed(3)),
+    purposeScore,
+    capabilityScore: Number(capabilityScore.toFixed(3)),
+    requiredCapabilities: required,
+    supportedCapabilities: supported,
+    missingCapabilities: required.filter((item) => !supported.includes(item)),
+    recommendedMode:
+      score >= 0.75
+        ? "inherit-narrative"
+        : score >= 0.5
+          ? "style-only"
+          : "recommend-other-template",
+  };
+}
+
+export function buildTemplateIntelligence({
+  manifest,
+  recipeDoc,
+  deckGrammar = {},
+  corrections = {},
+  semanticReview = null,
+}) {
+  const recipes = (recipeDoc.recipes || []).map((recipe) =>
+    effectiveRecipe(
+      recipe,
+      corrections.slides?.[String(recipe.sourceSlide)] || {},
+    ),
+  );
+  const kind = inferTemplateKind(recipes, manifest);
+  const slides = recipes.map((recipe) => {
+    const stats = slotStats(recipe);
+    const functions = communicationFunctions(recipe);
+    const blocked =
+      recipe.excludedFromAutoUse === true ||
+      (recipe.hardBlockReasons || []).length > 0;
+    const automatic =
+      !blocked &&
+      (recipe.approvedForAutoUse === true ||
+        (recipe.autoUseStatus === "ready" && Number(recipe.confidence) >= 0.65));
+    return {
+      sourceSlide: Number(recipe.sourceSlide),
+      layoutFamily: normalized(recipe.layoutFamily || "unknown"),
+      layoutVariant: recipe.layoutVariant || null,
+      narrativeRoles: [...new Set([normalized(recipe.narrativeRole), ...functions])]
+        .filter(Boolean)
+        .sort(),
+      communicationFunctions: functions,
+      density: recipe.density || null,
+      confidence: Number(recipe.confidence || 0),
+      safetyStatus: blocked ? "blocked" : automatic ? "automatic" : "review",
+      autoUseStatus: recipe.autoUseStatus || "review",
+      approvedForAutoUse: recipe.approvedForAutoUse === true,
+      hardBlockReasons: recipe.hardBlockReasons || [],
+      exclusionReason: recipe.exclusionReason || null,
+      capacity: {
+        ...(recipe.capacity || {}),
+        textSlotCount: Number(stats.byType.text || 0),
+        imageSlotCount: Number(stats.byType.image || 0),
+        tableSlotCount: Number(stats.byType.table || 0),
+        chartSlotCount: Number(stats.byType.chart || 0),
+      },
+      contentRecipe: inferContentRecipe(recipe, stats, functions),
+      slotSchema: (recipe.slots || []).map((slot) => ({
+        slotId: slot.slotId,
+        type: slot.type,
+        semanticType: slot.semanticType || slot.type,
+        purpose: slot.purpose,
+        required: slot.required === true,
+        maxChars: slot.maxChars,
+        maxTextUnits: slot.maxTextUnits,
+        maxLines: slot.maxLines,
+        rows: slot.rows,
+        columns: slot.columns,
+        operation: slot.operation || slot.action,
+      })),
+      assetRequirements: (recipe.visualRequirements || []).map((item) => ({
+        requirementId: item.requirementId,
+        type: item.type,
+        required: item.required === true,
+        status: item.status,
+        slotId: item.slotId,
+      })),
+      protectedElementCount: (recipe.protectedElementIds || []).length,
+      recipeFingerprint: recipe.recipeFingerprint,
+      previewSha256: recipe.previewSha256,
+    };
+  });
+  let profile = {
+    schemaVersion: 2,
+    engine: "ppt-template-reuse-template-intelligence",
+    templateSource: manifest.source,
+    templateKind: kind.kind,
+    templateKindConfidence: kind.confidence,
+    purposeProfile: inferPurposeProfile(recipes),
+    densityRange: inferDensity(recipes),
+    visualBalance: inferVisualBalance(recipes),
+    editability:
+      kind.kind === "flattened-deck" ? "selective-editability" : "native-editable",
+    narrativeGrammar: {
+      sourceOrderIsEvidence: kind.kind !== "layout-gallery",
+      sourceSequence: deckGrammar.sourceSequence || [],
+      positionProfiles: deckGrammar.positionProfiles || {},
+      observedTransitions: deckGrammar.observedTransitions || {},
+    },
+    slides,
+    capabilities: capabilityInventory(slides),
+    reviewSummary: {
+      automaticSlides: slides.filter((slide) => slide.safetyStatus === "automatic")
+        .map((slide) => slide.sourceSlide),
+      reviewSlides: slides.filter((slide) => slide.safetyStatus === "review")
+        .map((slide) => slide.sourceSlide),
+      blockedSlides: slides.filter((slide) => slide.safetyStatus === "blocked")
+        .map((slide) => slide.sourceSlide),
+    },
+    semanticReview: {
+      applied: false,
+    },
+  };
+  profile = applySemanticReview(profile, semanticReview);
+  profile.profileFingerprint = fingerprint({
+    ...profile,
+    profileFingerprint: undefined,
+  });
+  return profile;
+}
+
+function usage() {
+  return [
+    "Usage:",
+    "  node template-intelligence.mjs --capsule <capsule-dir> [--out <template-profile.json>]",
+    "       [--semantic-review <review.json>] [--brief <presentation-brief.json>]",
+  ].join("\n");
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log(usage());
+    return;
+  }
+  const capsuleDir = path.resolve(requireArg(args, "capsule"));
+  const manifest = await readJson(path.join(capsuleDir, "manifest.json"));
+  const recipeDoc = await readJson(path.join(capsuleDir, "slide-recipes.json"));
+  const correctionsPath = path.join(capsuleDir, "user-corrections.json");
+  const grammarPath = path.join(capsuleDir, "deck-grammar.json");
+  const corrections = (await exists(correctionsPath))
+    ? await readJson(correctionsPath)
+    : { slides: {} };
+  const deckGrammar = (await exists(grammarPath))
+    ? await readJson(grammarPath)
+    : {};
+  const semanticReview = args["semantic-review"]
+    ? await readJson(path.resolve(args["semantic-review"]))
+    : null;
+  const profile = buildTemplateIntelligence({
+    manifest,
+    recipeDoc,
+    deckGrammar,
+    corrections,
+    semanticReview,
+  });
+  if (args.brief) {
+    profile.fit = assessTemplateFit(
+      profile,
+      await readJson(path.resolve(args.brief)),
+    );
+  }
+  const outPath = path.resolve(
+    String(args.out || path.join(capsuleDir, "template-profile-v2.json")),
+  );
+  await writeJson(outPath, profile);
+  console.log(
+    JSON.stringify(
+      {
+        out: outPath,
+        templateKind: profile.templateKind,
+        primaryUseCases: profile.purposeProfile.primaryUseCases,
+        automaticSlides: profile.reviewSummary.automaticSlides.length,
+        reviewSlides: profile.reviewSummary.reviewSlides.length,
+        blockedSlides: profile.reviewSummary.blockedSlides.length,
+        fit: profile.fit || null,
+        profileFingerprint: profile.profileFingerprint,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+const isMain =
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+if (isMain) {
+  main().catch((error) => {
+    console.error(error.stack || error.message || String(error));
+    console.error(usage());
+    process.exit(1);
+  });
+}