@petercjl/taobao-ai-ops 0.1.0 → 0.1.2

package/skills/taobao-search-product-form/scripts/build_visual_review_viewmodel.py

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-"""Map three-axis visual evidence to the pinned workbench contract.
-
-This script writes a ViewModel only; the bundled runtime owns HTML rendering and QA.
-"""
-
-import argparse
-import hashlib
-import json
-from collections import Counter, defaultdict
-from pathlib import Path
-
-
-def load(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
-
-
-def digest(path):
-    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
-
-
-def title_count(label, count):
-    return f"{label} · {count}件"
-
-
-def build(args):
-    detail = load(args.labels)
-    summary = load(args.summary)
-    plan = load(args.plan)
-    if len(detail["records"]) != summary["reviewed_products"]:
-        raise ValueError("detail and summary product counts disagree")
-    products = detail["records"]
-    subject = args.subject.strip() or "搜索商品"
-    qa_note = args.qa_note.strip()
-    uncertain_count = sum(p["status"] == "uncertain" for p in products)
-    product_lookup = {p["product_id"]: p for p in products}
-    manifest = load(plan["source_manifest"])
-    source_lookup = {str(p["product_id"]): p for p in manifest["products"]}
-    assets = {}
-    for p in products:
-        assets[f"p{p['product_id']}"] = {"path": p["image_path"], "alt": f"商品 {p['product_id']} 主图",
-                                         "role": "source-product-image", "subject_id": p["product_id"],
-                                         "evidence_level": "direct"}
-
-    def product_card(p):
-        form = p["form"]["label"] or "款式待确认"
-        style = p["style"]["label"] or "风格未归类"
-        audience = p["audience"]["label"] or "人群证据不足"
-        source = source_lookup[p["product_id"]]
-        evidence = p["visible_evidence"]
-        if p["style"].get("physical_delta"):
-            evidence += "｜风格落点：" + p["style"]["physical_delta"]
-        if p["audience"].get("physical_delta"):
-            evidence += "｜任务适配：" + p["audience"]["physical_delta"]
-        return {"asset_id": f"p{p['product_id']}", "title": f"N{p['source_rank']} · {p['product_id']}",
-                "price": f"¥{source.get('price', 0):.2f}" if source.get("price") is not None else "价格未给出",
-                "badge": "边界待确认" if p["status"] == "uncertain" else "图片试打标",
-                "tone": "warning" if p["status"] == "uncertain" else "info",
-                "facts": [{"label": "款式", "value": form}, {"label": "风格", "value": style},
-                          {"label": "人群/任务", "value": audience}],
-                "evidence": evidence, "copy_value": p["product_id"], "copy_label": "复制商品ID"}
-
-    def sample_cards(axis, group, maximum=3):
-        return [product_card(p) for p in products if p[axis]["label"] == group][:maximum]
-
-    def group_view(axis, label, title, subtitle):
-        counts = summary["axes"][axis]["canonical_counts"]
-        rows = [[name, str(count), "、".join(summary["axes"][axis]["examples"].get(name, []))]
-                for name, count in sorted(counts.items(), key=lambda item: (-item[1], item[0]))]
-        tabs = [{"id": f"{axis}-{i+1}", "label": name, "badge": str(count),
-                 "blocks": [{"type": "products", "columns": 3, "items": sample_cards(axis, name)}]}
-                for i, (name, count) in enumerate(sorted(counts.items(), key=lambda item: (-item[1], item[0])))]
-        return {"id": axis, "label": label, "eyebrow": "三维打标", "title": title, "subtitle": subtitle,
-                "blocks": [{"type": "alert", "tone": "info",
-                            "text": f"本维度已归类 {sum(counts.values())} 件，未归类 {summary['axes'][axis]['unclassified_products']} 件；下方为各组代表图片。"},
-                           {"type": "table", "title": "标签分布", "columns": ["标签", "件数", "代表商品ID"], "rows": rows},
-                           {"type": "tabs", "title": "逐类看图", "tabs": tabs}]}
-
-    audience_counts = summary["axes"]["audience"]["canonical_counts"]
-    proposal_rows = []
-    for name, count in sorted(audience_counts.items(), key=lambda item: (-item[1], item[0])):
-        members = [p for p in products if p["audience"]["label"] == name]
-        forms = Counter(p["form"]["label"] or "边界待定" for p in members)
-        deltas = list(dict.fromkeys(p["audience"].get("physical_delta", "") for p in members))
-        proposal_rows.append([name, str(count), "、".join(f"{form} {n}" for form, n in forms.most_common()),
-                              "；".join(x for x in deltas[:2] if x)])
-    many_styles = []
-    by_form = defaultdict(Counter)
-    for p in products:
-        if p["form"]["label"] and p["style"]["label"]:
-            by_form[p["form"]["label"]][p["style"]["label"]] += 1
-    for form, styles in by_form.items():
-        if len(styles) >= 2:
-            many_styles.append([form, str(sum(styles.values())),
-                                "、".join(f"{style} {count}" for style, count in styles.most_common())])
-
-    model = {
-        "contract": "compact-workbench@1.0",
-        "meta": {"title": f"{subject}三维打标｜{len(products)}品审核版",
-                 "subtitle": f"款式 × 产品风格 × 任务型人群；自然位{len(products)}个商品的开发模式样例",
-                 "footer": "图片来自已提供的淘宝搜索导出；标签为待审核试打标，不代表全市场或实际购买人群。",
-                 "source_payload_sha256": digest(args.labels)},
-        "shell": {"brand_mark": "选", "brand_title": "商品形态审核", "brand_subtitle": "三维标签与可选货方案",
-                  "nav_label": "审核路径", "search": True, "search_placeholder": "搜索当前页面的商品ID或标签",
-                  "status": ["开发模式 · 待审核", f"{len(products)}件自然位商品", "结构/风格/任务三维"],
-                  "sidebar_tabs": True,
-                  "reading_path": [{"view_id": "overview", "label": "先看试打标边界"},
-                                   {"view_id": "form", "label": "再看结构款式"},
-                                   {"view_id": "style", "label": "比较产品风格"},
-                                   {"view_id": "audience", "label": "核对人群任务"},
-                                   {"view_id": "propositions", "label": "审视候选商品方案"},
-                                   {"view_id": "all", "label": "逐品核对"}]},
-        "assets": assets,
-        "views": [
-            {"id": "overview", "label": "结论与范围", "eyebrow": "待审核试跑", "title": "三维标签如何服务选款",
-             "subtitle": "当前只验证打标和聚合逻辑，不宣布市场机会。",
-             "blocks": [
-                 {"type": "conclusion", "title": "先看三项判断", "items": [
-                     {"label": "款式", "tone": "info", "segments": [{"text": "结构款式", "emphasis": "strong"}, {"text": "是基础分类；颜色不会单独拆出一个锅型。"}]},
-                     {"label": "风格", "tone": "positive", "segments": [{"text": "同一结构款可以形成不同的产品风格方案", "emphasis": "strong", "tone": "positive"}],
-                      "note": "风格必须对应锅体、手柄、表面等可见产品设计差异。"},
-                     {"label": "人群", "tone": "warning", "segments": [{"text": "目标人群是使用任务假设", "emphasis": "strong"},
-                          {"text": "，不是已验证的真实买家。", "emphasis": "italic", "tone": "warning"}],
-                      "note": "证据不足的商品保留空标签。"}]},
-                 {"type": "metrics", "columns": 4, "items": [
-                     {"label": "商品图片", "value": str(len(products)), "note": f"占清洗自然位 {len(products)}/{plan['scope']['manifest_natural_total']}"},
-                     {"label": "结构款式", "value": str(len(summary["axes"]["form"]["canonical_counts"])), "note": f"{uncertain_count}件目标边界待确认"},
-                     {"label": "风格已归类", "value": str(sum(summary["axes"]["style"]["canonical_counts"].values())), "note": "其余保留未归类"},
-                     {"label": "任务人群候选", "value": str(sum(audience_counts.values())), "note": "图片线索支持，仍需市场验证"}]},
-                 {"type": "alert", "title": "样本口径", "tone": "warning",
-                  "text": f"只选已清洗自然位的前{len(products)}个商品，并非随机抽样。品牌和排序可能造成偏斜；本页件数不是搜索市场份额。"},
-                 {"type": "list", "title": "读这份报告的顺序", "ordered": True,
-                  "items": ["先看每个维度的标签与代表图片，确认边界是否符合选款认知。",
-                            "再看同一结构款的风格差异，以及针对任务的产品结构变化。",
-                            "最后在逐品页核对全部50张图；有争议的标签回到原始观察，不直接修改聚合结果。"]}
-             ]},
-            group_view("form", "款式", "结构款式分类", f"主款式每商品最多一个；{uncertain_count}件目标范围待确认。"),
-            group_view("style", "风格", "产品设计风格", "仅用产品本身的形状、色彩、表面和部件；促销画面风格不入类。"),
-            group_view("audience", "人群", "目标任务人群候选", "标签指向使用任务及具体产品适配，不推断实际买家人口属性。"),
-            {"id": "propositions", "label": "候选商品方案", "eyebrow": "三维交叉", "title": "标签怎样变成可做的货",
-             "subtitle": "这些只是待研究的商品方案，不是投资、采购或入场建议。",
-             "blocks": [
-                 {"type": "alert", "tone": "info", "text": "下表只列样本中实际出现、且标注了产品侧变化的任务方向；稀少不等于有需求空缺。"},
-                 {"type": "table", "title": "任务驱动的候选方案", "columns": ["任务人群", "样本件数", "基础款式", "实际产品变化"], "rows": proposal_rows},
-                 {"type": "table", "title": "同款式的风格分化", "columns": ["基础款式", "有风格标签的件数", "可见风格"], "rows": many_styles},
-                 {"type": "callout", "text": "下一步需按商品ID联接价格、付款人数、店铺及广告位，再判断哪些组合有真实市场信号；图片本身不能证明白牌机会。"}]},
-            {"id": "all", "label": f"{len(products)}品逐项审核", "eyebrow": "完整证据", "title": "逐商品核对图片与标签",
-             "subtitle": "按自然位源排序；每张卡同时显示款式、风格、人群任务与可见依据。",
-             "blocks": [{"type": "alert", "tone": "warning", "text": qa_note or "识图次数、复核例外与并发能力以本次运行台账为准。"},
-                        {"type": "products", "columns": 3, "items": [product_card(p) for p in products]}]},
-            {"id": "method", "label": "口径与限制", "eyebrow": "方法", "title": "什么被标注，什么仍未知",
-             "subtitle": "三维可并行选款，证据等级不同。",
-             "blocks": [{"type": "list", "ordered": True,
-                         "items": ["款式是可见几何与结构的分类；主款式每个目标商品最多一个。",
-                                   "风格由至少两项产品本体线索支持，并写明可改变的产品设计部位。",
-                                   "人群是使用任务假设；必须有任务线索和可落到商品上的适配点。",
-                                   f"{uncertain_count}件目标边界待确认，等待上游目标范围决定是否纳入。",
-                                   "图片字样属于商家主张，不等于性能已验证；付款人数亦有不明时间窗口。",
-                                   "语义识图的实际并发量与重复阅读情况应按本次运行记录披露；不由图片下载并发推断。"]}]}
-        ]}
-    output = Path(args.output).resolve()
-    with output.open("x", encoding="utf-8") as stream:
-        json.dump(model, stream, ensure_ascii=False, indent=2)
-        stream.write("\n")
-    print(json.dumps({"viewmodel": str(output), "views": len(model["views"]),
-                      "assets": len(assets), "products": len(products)}, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--plan", required=True)
-    parser.add_argument("--labels", required=True)
-    parser.add_argument("--summary", required=True)
-    parser.add_argument("--output", required=True)
-    parser.add_argument("--subject", default="搜索商品")
-    parser.add_argument("--qa-note", default="")
-    build(parser.parse_args())

package/skills/taobao-search-product-form/scripts/clean_search_export.mjs

@@ -1,61 +0,0 @@
-#!/usr/bin/env node
-/** Split an XLSX search export into first-seen natural products and all advertising appearances. */
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import ExcelJS from '@excel.js/exceljs';
-
-const [sourcePath, outputPath] = process.argv.slice(2);
-if (!sourcePath || !outputPath) throw new Error('Usage: node clean_search_export.mjs SOURCE.xlsx OUTPUT.xlsx');
-if (!(await fs.stat(sourcePath)).isFile()) throw new Error('Source is not a file');
-if (await fs.stat(outputPath).then(() => true, e => { if (e.code === 'ENOENT') return false; throw e; })) {
-  throw new Error(`Output already exists: ${outputPath}`);
-}
-
-const source = new ExcelJS.Workbook();
-await source.xlsx.readFile(sourcePath);
-const input = source.worksheets[0];
-if (!input) throw new Error('Source workbook has no worksheet');
-const headers = input.getRow(1).values.slice(1).map(value => String(value ?? '').trim());
-const idColumn = headers.indexOf('商品ID');
-const placementColumn = headers.indexOf('占位类型');
-if (idColumn < 0 || placementColumn < 0) throw new Error('Source requires 商品ID and 占位类型 columns');
-
-const natural = [], ads = [], seenNatural = new Set();
-let duplicateNatural = 0;
-for (let rowIndex = 2; rowIndex <= input.rowCount; rowIndex++) {
-  const row = input.getRow(rowIndex);
-  const values = headers.map((_, columnIndex) => row.getCell(columnIndex + 1).value);
-  if (values.every(value => value === null || value === undefined || value === '')) continue;
-  const id = String(values[idColumn] ?? '').trim();
-  const placement = String(values[placementColumn] ?? '').trim();
-  if (!id) throw new Error(`Blank 商品ID at source row ${rowIndex}`);
-  values[idColumn] = id;
-  if (placement === '自然位') {
-    if (seenNatural.has(id)) { duplicateNatural++; continue; }
-    seenNatural.add(id);
-    natural.push(values);
-  } else if (placement === '广告位') ads.push(values);
-  else throw new Error(`Unknown 占位类型 at source row ${rowIndex}: ${placement}`);
-}
-
-const output = new ExcelJS.Workbook();
-for (const [name, data] of [['自然位', natural], ['广告位', ads]]) {
-  const sheet = output.addWorksheet(name, { views: [{ state: 'frozen', ySplit: 1 }] });
-  sheet.addRow(headers);
-  for (const values of data) sheet.addRow(values);
-  sheet.getColumn(idColumn + 1).numFmt = '@';
-  sheet.getRow(1).font = { name: 'Arial', size: 10, bold: true, color: { argb: 'FFFFFFFF' } };
-  sheet.getRow(1).fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF1F3A5F' } };
-  sheet.autoFilter = { from: { row: 1, column: 1 }, to: { row: data.length + 1, column: headers.length } };
-  sheet.columns.forEach((column, index) => { column.width = index === 2 ? 48 : 20; });
-}
-await fs.mkdir(path.dirname(outputPath), { recursive: true });
-await output.xlsx.writeFile(outputPath);
-console.log(JSON.stringify({
-  sourceRows: natural.length + ads.length + duplicateNatural,
-  naturalSourceRows: natural.length + duplicateNatural,
-  naturalRetainedRows: natural.length,
-  naturalDuplicateRowsRemoved: duplicateNatural,
-  adRowsRetained: ads.length,
-  output: outputPath,
-}, null, 2));

package/skills/taobao-search-product-form/scripts/cluster_visual_forms.py

@@ -1,193 +0,0 @@
-#!/usr/bin/env python3
-"""Prepare and apply an auditable, category-neutral visual-form hierarchy.
-
-Semantic family decisions are made by the host Agent from class profiles and
-representative image observations. This script validates and applies them; it
-never derives form identity from title, price, payments, or a preset class list.
-Outputs must be new paths so raw image observations remain immutable.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import re
-from collections import Counter, defaultdict
-from pathlib import Path
-
-
-def load(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
-
-
-def save_new(path, value):
-    target = Path(path)
-    target.parent.mkdir(parents=True, exist_ok=True)
-    with target.open("x", encoding="utf-8") as stream:
-        json.dump(value, stream, ensure_ascii=False, indent=2)
-        stream.write("\n")
-
-
-def grams(value):
-    text = re.sub(r"\s+", "", value.casefold())
-    if len(text) < 2:
-        return {text}
-    return {text[index:index + 2] for index in range(len(text) - 1)}
-
-
-def similarity(left, right):
-    a, b = grams(left), grams(right)
-    return round(len(a & b) / len(a | b), 3) if a | b else 0.0
-
-
-def prepare(labels_path, summary_path, output_path):
-    labels, summary = load(labels_path), load(summary_path)
-    records = labels["records"]
-    counts = summary["axes"]["form"]["canonical_counts"]
-    by_label = defaultdict(list)
-    for row in records:
-        name = row["form"].get("label")
-        if name:
-            by_label[name].append(row)
-    if {name: len(rows) for name, rows in by_label.items()} != counts:
-        raise ValueError("form summary and product labels disagree")
-    profiles = []
-    for name, rows in sorted(by_label.items(), key=lambda item: (-len(item[1]), item[0])):
-        examples = sorted(rows, key=lambda row: row["source_rank"])[:3]
-        profiles.append({
-            "source_label": name,
-            "products": len(rows),
-            "candidate_words": dict(Counter(row["form"].get("candidate") for row in rows).most_common(8)),
-            "style_counts": dict(Counter(row["style"].get("label") for row in rows if row["style"].get("label")).most_common(5)),
-            "task_counts": dict(Counter(row["audience"].get("label") for row in rows if row["audience"].get("label")).most_common(5)),
-            "examples": [{"product_id": row["product_id"], "visible_evidence": row["visible_evidence"],
-                          "image_path": row["image_path"]} for row in examples],
-        })
-    neighbors = []
-    for index, first in enumerate(profiles):
-        options = sorted(({"source_label": other["source_label"],
-                           "name_similarity": similarity(first["source_label"], other["source_label"])}
-                          for j, other in enumerate(profiles) if j != index),
-                         key=lambda row: (-row["name_similarity"], row["source_label"]))
-        neighbors.append({"source_label": first["source_label"], "possible_neighbors": options[:5]})
-    save_new(output_path, {"schema_version": 1, "purpose": "semantic form-family adjudication input",
-                           "source_registry_version": summary.get("registry_version"),
-                           "product_count": sum(counts.values()), "profiles": profiles,
-                           "name_neighbors_for_recall_only": neighbors,
-                           "boundary": "Name similarity proposes comparisons; image-grounded structure decides grouping."})
-
-
-def apply(labels_path, summary_path, decisions_path, output_dir):
-    labels, summary, decisions = load(labels_path), load(summary_path), load(decisions_path)
-    if decisions.get("schema_version") != 1:
-        raise ValueError("cluster decision schema_version must be 1")
-    original_counts = summary["axes"]["form"]["canonical_counts"]
-    rows = decisions.get("mappings", [])
-    if not rows and decisions.get("families"):
-        for family in decisions["families"]:
-            for variant in family.get("variants", []):
-                for source in variant.get("sources", []):
-                    rows.append({"source_label": source, "family": family["family"],
-                                 "variant": variant["variant"],
-                                 "features": variant.get("features", []),
-                                 "reason": variant.get("reason") or family.get("reason"),
-                                 "confidence": variant.get("confidence", family.get("confidence", "high"))})
-    owners = {}
-    for row in rows:
-        source = str(row.get("source_label") or "").strip()
-        family = str(row.get("family") or "").strip()
-        variant = str(row.get("variant") or "").strip()
-        reason = str(row.get("reason") or "").strip()
-        features = row.get("features", [])
-        confidence = row.get("confidence")
-        if not source or source in owners or not family or not variant or not reason:
-            raise ValueError(f"incomplete or duplicate mapping: {source!r}")
-        if confidence not in ("high", "medium", "low"):
-            raise ValueError(f"invalid confidence for {source}")
-        if not isinstance(features, list) or any(not isinstance(x, str) or not x.strip() for x in features):
-            raise ValueError(f"invalid features for {source}")
-        owners[source] = {"family": family, "variant": variant,
-                          "features": list(dict.fromkeys(x.strip() for x in features)),
-                          "reason": reason, "confidence": confidence}
-    if set(owners) != set(original_counts):
-        raise ValueError(f"mapping coverage differs: missing={sorted(set(original_counts)-set(owners))}, "
-                         f"extra={sorted(set(owners)-set(original_counts))}")
-    if not decisions.get("semantic_review") or not decisions["semantic_review"].get("method"):
-        raise ValueError("semantic_review.method is required")
-
-    family_counts, variant_counts = Counter(), Counter()
-    family_examples = defaultdict(list)
-    family_sources = defaultdict(list)
-    for source, decision in owners.items():
-        family_sources[decision["family"]].append(source)
-    updated = []
-    for source_row in labels["records"]:
-        row = json.loads(json.dumps(source_row, ensure_ascii=False))
-        original = row["form"].get("label")
-        if original:
-            decision = owners[original]
-            family, variant = decision["family"], decision["variant"]
-            row["form"].update({"source_label": original, "label": family,
-                                "variant": variant, "features": decision["features"],
-                                "cluster_confidence": decision["confidence"]})
-            family_counts[family] += 1
-            variant_counts[(family, variant)] += 1
-            if len(family_examples[family]) < 3:
-                family_examples[family].append(row["product_id"])
-        updated.append(row)
-    if sum(family_counts.values()) != sum(original_counts.values()):
-        raise ValueError("product population changed during clustering")
-    result_summary = json.loads(json.dumps(summary, ensure_ascii=False))
-    axis = result_summary["axes"]["form"]
-    axis["source_canonical_counts"] = dict(original_counts)
-    axis["source_examples"] = axis["examples"]
-    axis["canonical_counts"] = dict(family_counts)
-    axis["examples"] = dict(family_examples)
-    axis["variant_counts"] = [{"family": family, "variant": variant, "products": count}
-                              for (family, variant), count in sorted(variant_counts.items())]
-    axis["family_sources"] = {key: sorted(value) for key, value in family_sources.items()}
-    result_summary["strategy"] = "visual-selection-three-axis-hierarchical-v1"
-    result_summary["form_cluster"] = {"method": decisions["semantic_review"]["method"],
-                                      "source_class_count": len(original_counts),
-                                      "family_count": len(family_counts),
-                                      "variant_count": len(variant_counts),
-                                      "source_singletons": sum(count == 1 for count in original_counts.values()),
-                                      "family_singletons": sum(count == 1 for count in family_counts.values()),
-                                      "low_confidence_sources": [source for source, item in owners.items()
-                                                                 if item["confidence"] == "low"]}
-    result_summary["qa"]["form_cluster_mapping_complete"] = True
-    result_summary["qa"]["form_cluster_population_preserved"] = True
-    result_summary["qa"]["form_cluster_semantic_review_recorded"] = True
-    target = Path(output_dir)
-    if target.exists():
-        raise FileExistsError(target)
-    target.mkdir(parents=True)
-    save_new(target / "product_labels.json", {"schema_version": labels["schema_version"], "records": updated})
-    save_new(target / "label_summary.json", result_summary)
-    save_new(target / "cluster_audit.json", {"schema_version": 1, "mappings": rows,
-                                             "family_sources": result_summary["axes"]["form"]["family_sources"],
-                                             "counts": result_summary["form_cluster"],
-                                             "semantic_review": decisions["semantic_review"]})
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    sub = parser.add_subparsers(dest="command", required=True)
-    first = sub.add_parser("prepare")
-    first.add_argument("--labels", required=True)
-    first.add_argument("--summary", required=True)
-    first.add_argument("--output", required=True)
-    second = sub.add_parser("apply")
-    second.add_argument("--labels", required=True)
-    second.add_argument("--summary", required=True)
-    second.add_argument("--decisions", required=True)
-    second.add_argument("--output-dir", required=True)
-    args = parser.parse_args()
-    if args.command == "prepare":
-        prepare(args.labels, args.summary, args.output)
-    else:
-        apply(args.labels, args.summary, args.decisions, args.output_dir)
-
-
-if __name__ == "__main__":
-    main()

package/skills/taobao-search-product-form/scripts/compile_style_prototypes.py

@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-"""Validate image-bound product-style decisions and compile reusable evidence."""
-
-import argparse
-import hashlib
-import json
-from collections import Counter
-from pathlib import Path
-
-
-def load(path):
-    return json.loads(Path(path).read_text(encoding="utf-8"))
-
-
-def digest(path):
-    return hashlib.sha256(Path(path).read_bytes()).hexdigest()
-
-
-def require(condition, message):
-    if not condition:
-        raise ValueError(message)
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--plan", required=True)
-    parser.add_argument("--observations", required=True)
-    parser.add_argument("--decisions", required=True)
-    parser.add_argument("--output-dir", required=True)
-    args = parser.parse_args()
-
-    plan, observations, decisions = map(load, (args.plan, args.observations, args.decisions))
-    require(decisions.get("schema_version") == 1, "decisions.schema_version must be 1")
-    require(decisions.get("source_plan_sha256") == digest(args.plan), "plan checksum mismatch")
-    require(decisions.get("source_observations_sha256") == digest(args.observations), "observations checksum mismatch")
-    items = {str(item["product_id"]): item for item in plan["items"] if item["status"] == "ready"}
-    require(len(items) == sum(item["status"] == "ready" for item in plan["items"]), "duplicate ready IDs")
-    raw = {str(item["product_id"]): item for item in observations["records"]}
-    require(len(raw) == len(observations["records"]) == len(items), "observation population mismatch")
-    require(set(raw) == set(items), "observation IDs differ from ready image IDs")
-    for product_id, item in items.items():
-        require(raw[product_id]["image_sha256"] == item["image_sha256"], f"raw image hash mismatch: {product_id}")
-
-    prototypes = decisions.get("prototypes", [])
-    prototype_ids = [entry["style_id"] for entry in prototypes]
-    require(len(prototype_ids) == len(set(prototype_ids)) and prototypes, "duplicate or missing prototypes")
-    for entry in prototypes:
-        for field in ("style_id", "name", "definition", "selection_difference", "boundary", "representative_ids"):
-            require(entry.get(field), f"prototype {entry.get('style_id')} lacks {field}")
-        require(isinstance(entry["representative_ids"], list), "representative_ids must be a list")
-
-    records = decisions.get("assignments", [])
-    assigned_ids = [str(row["product_id"]) for row in records]
-    require(len(records) == len(items) == len(set(assigned_ids)), "assignment population/duplicates mismatch")
-    require(set(assigned_ids) == set(items), "assignment IDs differ from ready image IDs")
-    by_id = {str(row["product_id"]): row for row in records}
-    groups = {style_id: [] for style_id in prototype_ids}
-    labels = []
-    uncertainty = []
-    for product_id, item in items.items():
-        row = by_id[product_id]
-        style_ids = row.get("style_ids", [])
-        boundary_reason = row.get("boundary_reason")
-        require(row.get("image_sha256") == item["image_sha256"], f"decision image hash mismatch: {product_id}")
-        require(isinstance(style_ids, list) and len(style_ids) == len(set(style_ids)), f"invalid style IDs: {product_id}")
-        require(all(style_id in groups for style_id in style_ids), f"unknown prototype: {product_id}")
-        require(bool(style_ids) != bool(boundary_reason), f"assign style(s) or boundary: {product_id}")
-        require(row.get("reason") and row.get("confidence") in ("high", "medium", "low"), f"missing reason/confidence: {product_id}")
-        for style_id in style_ids:
-            groups[style_id].append(product_id)
-        if row["confidence"] == "low" or boundary_reason:
-            uncertainty.append(product_id)
-        labels.append({
-            "product_id": product_id,
-            "image_path": item["image_path"],
-            "image_sha256": item["image_sha256"],
-            "source_rank": item.get("source_rank"),
-            "batch_id": item.get("batch_id"),
-            "style_ids": style_ids,
-            "variant_or_features": row.get("variant_or_features", []),
-            "reason": row["reason"],
-            "confidence": row["confidence"],
-            "boundary_reason": boundary_reason,
-            "visible_evidence": raw[product_id].get("visible_evidence"),
-        })
-    for entry in prototypes:
-        style_id = entry["style_id"]
-        require(groups[style_id], f"empty prototype: {style_id}")
-        require(all(str(pid) in groups[style_id] for pid in entry["representative_ids"]), f"representative outside group: {style_id}")
-
-    out = Path(args.output_dir)
-    require(not out.exists(), "output directory already exists; choose a new versioned path")
-    out.mkdir(parents=True)
-    summary = [{**entry, "product_count": len(groups[entry["style_id"]]), "product_ids": groups[entry["style_id"]]} for entry in prototypes]
-    audit = {
-        "source_plan_sha256": digest(args.plan),
-        "source_observations_sha256": digest(args.observations),
-        "source_decisions_sha256": digest(args.decisions),
-        "ready_count": len(items),
-        "assigned_count": len(labels),
-        "classified_count": sum(bool(row["style_ids"]) for row in labels),
-        "boundary_count": sum(bool(row["boundary_reason"]) for row in labels),
-        "multi_style_count": sum(len(row["style_ids"]) > 1 for row in labels),
-        "memberships": sum(len(row["style_ids"]) for row in labels),
-        "prototype_count": len(prototypes),
-        "confidence_counts": dict(Counter(row["confidence"] for row in labels)),
-        "review_ids": uncertainty,
-    }
-    for name, data in (("product_style_labels.json", labels), ("style_prototype_summary.json", summary), ("style_prototype_audit.json", audit)):
-        (out / name).write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    print(json.dumps({"output_dir": str(out), **{key: audit[key] for key in ("ready_count", "classified_count", "boundary_count", "prototype_count", "memberships")}}, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()

package/skills/taobao-search-product-form/scripts/compile_visual_review.py

@@ -1,60 +0,0 @@
-#!/usr/bin/env python3
-"""Compile a visually reviewed position ledger to product/image-linked labels."""
-
-import argparse
-import json
-from pathlib import Path
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--manifest", required=True)
-    parser.add_argument("--review", required=True)
-    parser.add_argument("--output", required=True)
-    args = parser.parse_args()
-    output = Path(args.output).expanduser().resolve()
-    if output.exists():
-        parser.error("output already exists; choose a new path")
-    manifest = json.loads(Path(args.manifest).read_text(encoding="utf-8"))
-    review = json.loads(Path(args.review).read_text(encoding="utf-8"))
-    products = {p["product_id"]: p for p in manifest["products"]}
-    selected = manifest["selected_organic_ids"] + manifest["selected_ad_only_ids"]
-    positions = {}
-    for pid in selected:
-        p = products[pid]
-        key = "N" + str(p["first_natural"]) if p["first_natural"] else "A" + str(p["first_ad"])
-        if key in positions:
-            raise ValueError(f"duplicate display-position key: {key}")
-        positions[key] = pid
-    labeled = {}
-    for group in review["groups"]:
-        eligibility = group["eligibility"]
-        form = group.get("form")
-        evidence = group.get("visible_evidence")
-        for key in group["positions"]:
-            if key not in positions or key in labeled:
-                raise ValueError(f"unknown or duplicate reviewed position: {key}")
-            pid = positions[key]
-            fetch = manifest["fetches"].get(pid, {})
-            if fetch.get("status") != "ok":
-                raise ValueError(f"image unavailable for {key}")
-            labeled[key] = {
-                "product_id": pid,
-                "image_path": fetch["path"],
-                "eligibility": eligibility,
-                "form": form if eligibility == "target" else None,
-                "visible_evidence": evidence,
-                "confidence": "medium" if eligibility == "uncertain" else "high",
-                "review_position": key,
-            }
-    missing = set(positions) - set(labeled)
-    if missing:
-        raise ValueError(f"review is incomplete; missing: {sorted(missing)}")
-    output.parent.mkdir(parents=True, exist_ok=True)
-    with output.open("x", encoding="utf-8") as handle:
-        json.dump({"schema_version": 1, "search_term": manifest["search_term"], "scope": manifest["scope"], "review_basis": review["review_basis"], "labels": list(labeled.values())}, handle, ensure_ascii=False, indent=2)
-    print(json.dumps({"output": str(output), "labels": len(labeled)}, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()