vision-electronic-indexing-pi 0.1.3 → 0.1.5

package/.pi/extensions/vision-inventory-mcp/README.md

@@ -60,7 +60,7 @@ The agent workflow:
 - `/vision-inventory-agent-bom` runs the full agent-assisted datasheet-enrichment workflow.
 - `/vision-inventory-restart` restarts the local Python vision bridge.
 
-Options are forwarded to `scripts/inventory_folder_to_csv.py`, such as `--recursive`, `--limit`, `--max-side`, and `--jpeg-quality`.
+Options are forwarded to `scripts/inventory_folder_to_csv.py`, such as `--recursive`, `--limit`, `--max-side`, and `--jpeg-quality`. The default `--max-side 0` sends images at full resolution; set a positive value to resize.
 
 ## Agent tools
 

package/.pi/extensions/vision-inventory-mcp/index.ts

@@ -362,7 +362,7 @@ export default function (pi: ExtensionAPI) {
     ],
     parameters: Type.Object({
       image_path: Type.String({ description: "Path to the image file, relative to the project root or absolute." }),
-      max_side: Type.Optional(Type.Integer({ description: "Maximum resized image side before submission.", default: 4000 })),
+      max_side: Type.Optional(Type.Integer({ description: "Maximum resized image side before submission. Use 0 for full resolution.", default: 0 })),
       jpeg_quality: Type.Optional(Type.Integer({ description: "JPEG conversion quality from 1 to 100.", default: 96 })),
       custom_prompt: Type.Optional(Type.String({ description: "Optional custom analysis prompt." })),
     }),
@@ -383,7 +383,7 @@ export default function (pi: ExtensionAPI) {
     parameters: Type.Object({
       folder_path: Type.String({ description: "Folder path, relative to the project root or absolute." }),
       recursive: Type.Optional(Type.Boolean({ description: "Whether to scan subfolders.", default: false })),
-      max_side: Type.Optional(Type.Integer({ description: "Maximum resized image side before submission.", default: 4000 })),
+      max_side: Type.Optional(Type.Integer({ description: "Maximum resized image side before submission. Use 0 for full resolution.", default: 0 })),
       jpeg_quality: Type.Optional(Type.Integer({ description: "JPEG conversion quality from 1 to 100.", default: 96 })),
       limit: Type.Optional(Type.Integer({ description: "Optional maximum number of images to process." })),
     }),

package/.pi/skills/vision-inventory-workflow/SKILL.md

@@ -23,7 +23,7 @@ Use `/vision-inventory-setup` to configure credentials and check/install Python
 /vision-inventory-agent-bom <image_folder> <output_dir> [options]
 ```
 
-Options are forwarded to `scripts/inventory_folder_to_csv.py`, for example `--recursive`, `--limit 3`, `--max-side 4000`, and `--jpeg-quality 96`.
+Options are forwarded to `scripts/inventory_folder_to_csv.py`, for example `--recursive`, `--limit 3`, `--max-side 0`, and `--jpeg-quality 96`. `--max-side 0` means full resolution and is the default.
 
 ## Agent Rules
 

package/README.md

@@ -99,7 +99,7 @@ Useful options:
 ```text
 /vision-inventory-agent-bom ./photos ./output --recursive
 /vision-inventory-agent-bom ./photos ./output --limit 3
-/vision-inventory-agent-bom ./photos ./output --max-side 4000 --jpeg-quality 96
+/vision-inventory-agent-bom ./photos ./output --max-side 0 --jpeg-quality 96
 ```
 
 The agent workflow will:
@@ -135,13 +135,13 @@ verified=false
 
 ## CSV output columns
 
-`inventory.csv` is deduplicated by normalized part number. Multiple images, or multiple candidates from one image, can merge into one BOM row.
+`inventory.csv` is deduplicated by `normalized_part`, the main/final part number column derived from the vision `likely_part` and datasheet enrichment. Multiple images, or multiple candidates from one image, can merge into one BOM row when they resolve to the same `normalized_part`.
 
 Columns:
 
 | Column | Description |
 |---|---|
-| `normalized_part` | Final normalized part number, usually from datasheet enrichment. |
+| `normalized_part` | Main dedupe key/final part number, usually from datasheet enrichment and based on the vision `likely_part`. |
 | `candidate_parts` | Candidate part numbers extracted from visual markings. |
 | `amount` | Estimated quantity for the merged BOM row. |
 | `sighting_count` | Number of evidence rows merged into this BOM row. |
@@ -242,7 +242,7 @@ Before sending an image to Cloudflare Workers AI, the Python server:
 
 1. Opens the image with Pillow.
 2. Applies EXIF orientation correction.
-3. Resizes only if the image is larger than `max_side`.
+3. Sends full resolution by default; resizes only when `max_side` is set to a positive value and the image is larger than that limit.
 4. Converts transparency to a white background.
 5. Converts the image to RGB.
 6. Encodes it as JPEG.
@@ -251,7 +251,7 @@ Before sending an image to Cloudflare Workers AI, the Python server:
 Defaults:
 
 ```text
-max_side: 4000
+max_side: 0 (full resolution)
 jpeg_quality: 96
 model: @cf/meta/llama-4-scout-17b-16e-instruct
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vision-electronic-indexing-pi",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Pi package for agent-assisted electronics/PCB image inventory with Cloudflare Workers AI vision and datasheet enrichment.",
   "license": "MIT",
   "repository": {

package/scripts/inventory_folder_to_csv.py

@@ -228,15 +228,17 @@ def lookup_enrichment(part: str, cache: Dict[str, Any]) -> Dict[str, Any]:
 def estimate_amount_for_candidate(result: Dict[str, Any], candidate: str, evidence_count: int = 1) -> int:
     """Estimate physical IC quantity for one candidate in one image.
 
-    Count separate matching IC items. The schema field count_index is treated as
-    an ordinal/index, not a quantity. Fall back to the number of candidate
-    evidence rows when only observations are available.
+    Some vision results use count_index as a grouped visible count, while others
+    use it as an ordinal. Use the maximum of matching item count, evidence count,
+    and any numeric count_index values so grouped detections like count_index=4
+    produce amount=4 without double-counting duplicate observations.
     """
     items = result.get("items", [])
     if not isinstance(items, list):
         return max(1, evidence_count)
 
     matched = 0
+    count_values: List[int] = []
     for item in items:
         if not isinstance(item, dict):
             continue
@@ -245,10 +247,12 @@ def estimate_amount_for_candidate(result: Dict[str, Any], candidate: str, eviden
         if candidate_from_item(item).upper() != candidate.upper():
             continue
         matched += 1
+        try:
+            count_values.append(max(1, int(item.get("count_index", 1))))
+        except Exception:
+            pass
 
-    if matched > 0:
-        return matched
-    return max(1, evidence_count)
+    return max([1, evidence_count, matched, *count_values])
 
 
 def image_part_rows(results: List[Dict[str, Any]], cache: Dict[str, Any]) -> List[Dict[str, Any]]:
@@ -286,8 +290,10 @@ def image_part_rows(results: List[Dict[str, Any]], cache: Dict[str, Any]) -> Lis
 
         for candidate, candidate_evidence in sorted(evidence_by_candidate.items()):
             enrichment = lookup_enrichment(candidate, cache)
+            likely_part = str(enrichment.get("normalized_part") or candidate).strip().upper()
             amount = estimate_amount_for_candidate(result, candidate, evidence_count=len(candidate_evidence))
-            observed_markings = sorted({row["observed_marking"] for row in candidate_evidence})
+            # Keep observed_markings normalized to the main visible part number, not full date/lot/package text.
+            observed_markings = [likely_part]
             observations = "; ".join(
                 f"{row['position_hint']}: {row['observed_marking']} ({row['marking_confidence']})"
                 for row in candidate_evidence
@@ -298,7 +304,7 @@ def image_part_rows(results: List[Dict[str, Any]], cache: Dict[str, Any]) -> Lis
             rows.append({
                 "image": image_name,
                 "candidate_part": candidate,
-                "normalized_part": enrichment.get("normalized_part", candidate),
+                "normalized_part": likely_part,
                 "amount": amount,
                 "description": enrichment.get("description", ""),
                 "datasheet_url": enrichment.get("datasheet_url", ""),
@@ -424,7 +430,7 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--recursive", action="store_true", help="Scan image_folder recursively")
     parser.add_argument("--limit", type=int, default=None, help="Maximum number of images to process")
     parser.add_argument("--skip-vision", action="store_true", help="Reuse existing output_dir/raw/*.json instead of calling vision AI")
-    parser.add_argument("--max-side", type=int, default=vision.DEFAULT_MAX_SIDE, help="Maximum resized image side")
+    parser.add_argument("--max-side", type=int, default=vision.DEFAULT_MAX_SIDE, help="Maximum resized image side; use 0 for full resolution (default)")
     parser.add_argument("--jpeg-quality", type=int, default=vision.DEFAULT_JPEG_QUALITY, help="JPEG quality for model input")
     return parser.parse_args()
 

package/vision_inventory_mcp.py

@@ -56,7 +56,7 @@ except ImportError:  # pragma: no cover - compatibility fallback
 
 
 DEFAULT_MODEL = os.getenv("WORKERS_AI_MODEL", "@cf/meta/llama-4-scout-17b-16e-instruct")
-DEFAULT_MAX_SIDE = 4000
+DEFAULT_MAX_SIDE = 0
 DEFAULT_JPEG_QUALITY = 96
 DEFAULT_MAX_TOKENS = 1600
 DEFAULT_TEMPERATURE = 0.05
@@ -184,8 +184,8 @@ def prepare_image_data_url(
     max_side: int = DEFAULT_MAX_SIDE,
     jpeg_quality: int = DEFAULT_JPEG_QUALITY,
 ) -> Tuple[Optional[str], Optional[Dict[str, Any]]]:
-    if max_side < 256:
-        return None, error_response("max_side must be at least 256.")
+    if max_side and max_side < 256:
+        return None, error_response("max_side must be 0 for full resolution or at least 256.")
 
     if jpeg_quality < 1 or jpeg_quality > 100:
         return None, error_response("jpeg_quality must be between 1 and 100.")
@@ -194,8 +194,9 @@ def prepare_image_data_url(
         image = Image.open(image_path)
         image = ImageOps.exif_transpose(image)
 
-        resample = getattr(Image, "Resampling", Image).LANCZOS
-        image.thumbnail((max_side, max_side), resample)
+        if max_side:
+            resample = getattr(Image, "Resampling", Image).LANCZOS
+            image.thumbnail((max_side, max_side), resample)
 
         # Convert transparency to white background before JPEG encoding.
         if image.mode in ("RGBA", "LA"):
@@ -645,8 +646,15 @@ def count_inventory_rows(inventory: Dict[str, Any]) -> int:
     return 0
 
 
-def flatten_inventory_for_csv(inventory: Dict[str, Any]) -> List[Dict[str, Any]]:
-    rows: List[Dict[str, Any]] = []
+def flatten_inventory_for_csv(inventory: Dict[str, Any], enrichment_cache: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+    """Flatten raw vision output into BOM-style, likely-part-deduped CSV rows.
+
+    This is intentionally less complete than scripts/inventory_folder_to_csv.py
+    because the save tool only receives in-memory vision output. If a
+    datasheet_cache.json object is provided, matching enrichment fields are used.
+    """
+    grouped: Dict[str, List[Dict[str, Any]]] = {}
+    cache = enrichment_cache or {}
 
     if isinstance(inventory.get("items"), list):
         image_results = [inventory]
@@ -659,31 +667,64 @@ def flatten_inventory_for_csv(inventory: Dict[str, Any]) -> List[Dict[str, Any]]
             continue
 
         image_name = str(result.get("image", "unknown"))
-        warnings = result.get("warnings", [])
-        if isinstance(warnings, list):
-            warnings_text = " | ".join(str(w) for w in warnings)
-        else:
-            warnings_text = str(warnings)
-
         items = result.get("items", [])
         if not isinstance(items, list):
             continue
 
+        by_image_part: Dict[Tuple[str, str], Dict[str, Any]] = {}
         for item in items:
             if not isinstance(item, dict):
                 continue
-            rows.append({
+            if str(item.get("item_type", "")).strip().lower() != "ic":
+                continue
+
+            candidate = str(item.get("likely_part") or item.get("package_marking") or "unknown").strip().upper()
+            if not candidate or candidate.lower() in {"unknown", "unreadable", "unclear", "none", "n/a"}:
+                continue
+            enrichment = cache.get(candidate, {}) if isinstance(cache.get(candidate, {}), dict) else {}
+            normalized = str(enrichment.get("normalized_part") or candidate).strip().upper()
+            key = (image_name, normalized)
+            row = by_image_part.setdefault(key, {
                 "image": image_name,
-                "item_type": item.get("item_type", "unknown"),
-                "count_index": item.get("count_index", ""),
-                "package_marking": item.get("package_marking", "unknown"),
-                "marking_confidence": item.get("marking_confidence", "unreadable"),
-                "likely_part": item.get("likely_part", "unknown"),
-                "description": item.get("description", "unknown"),
-                "position_hint": item.get("position_hint", "unknown"),
-                "needs_review": item.get("needs_review", True),
-                "warnings": warnings_text,
+                "normalized_part": normalized,
+                "candidate_parts": set(),
+                "amount": 0,
+                "vision_confidence": set(),
+                "needs_review": False,
+                "observed_markings": set(),
             })
+            row["candidate_parts"].add(candidate)
+            row["vision_confidence"].add(str(item.get("marking_confidence", "unknown")))
+            row["needs_review"] = bool(row["needs_review"] or item.get("needs_review", True))
+            # Keep the main part number as the observation, not the full package/date/lot marking.
+            row["observed_markings"].add(normalized)
+            try:
+                row["amount"] = max(int(row["amount"]), int(item.get("count_index", 1)))
+            except Exception:
+                row["amount"] = max(int(row["amount"]), 1)
+
+        for row in by_image_part.values():
+            grouped.setdefault(str(row["normalized_part"]), []).append(row)
+
+    rows: List[Dict[str, Any]] = []
+    for part, part_rows in sorted(grouped.items()):
+        enrichment = cache.get(part, {}) if isinstance(cache.get(part, {}), dict) else {}
+        rows.append({
+            "normalized_part": part,
+            "candidate_parts": " | ".join(sorted({candidate for row in part_rows for candidate in row["candidate_parts"]})),
+            "amount": sum(int(row.get("amount", 0) or 0) for row in part_rows),
+            "sighting_count": len(part_rows),
+            "description": enrichment.get("description", ""),
+            "datasheet_url": enrichment.get("datasheet_url", ""),
+            "manufacturer": enrichment.get("manufacturer", ""),
+            "verified": bool(enrichment.get("verified", False)),
+            "vision_confidence": "/".join(sorted({value for row in part_rows for value in row["vision_confidence"]})),
+            "needs_review": any(bool(row.get("needs_review", True)) for row in part_rows) or not bool(enrichment.get("verified", False)),
+            "images": " | ".join(sorted({str(row["image"]) for row in part_rows})),
+            "observed_markings": " | ".join(sorted({marking for row in part_rows for marking in row["observed_markings"]})),
+            "raw_json": "",
+            "notes": enrichment.get("notes", "Missing datasheet enrichment"),
+        })
 
     return rows
 
@@ -719,18 +760,32 @@ def save_inventory(
             row_count = count_inventory_rows(inventory)
 
         else:
-            rows = flatten_inventory_for_csv(inventory)
+            cache_path = output.parent / "datasheet_cache.json"
+            enrichment_cache: Dict[str, Any] = {}
+            if cache_path.exists():
+                try:
+                    loaded_cache = json.loads(cache_path.read_text(encoding="utf-8"))
+                    if isinstance(loaded_cache, dict):
+                        enrichment_cache = loaded_cache
+                except Exception:
+                    enrichment_cache = {}
+
+            rows = flatten_inventory_for_csv(inventory, enrichment_cache)
             fieldnames = [
-                "image",
-                "item_type",
-                "count_index",
-                "package_marking",
-                "marking_confidence",
-                "likely_part",
+                "normalized_part",
+                "candidate_parts",
+                "amount",
+                "sighting_count",
                 "description",
-                "position_hint",
+                "datasheet_url",
+                "manufacturer",
+                "verified",
+                "vision_confidence",
                 "needs_review",
-                "warnings",
+                "images",
+                "observed_markings",
+                "raw_json",
+                "notes",
             ]
 
             with output.open("w", newline="", encoding="utf-8") as csv_file: