chore: initialize repository baseline

Import the existing Electron + React + TypeScript app as the version-control baseline before the scanner rework (C# input/capture sidecar, resolution-anchored layout profiles, OCR preprocessing, eval harness, rescan-merge, GOOD interop). Housekeeping in this commit: - Remove orphaned temp_inputhelper_block.ts (duplicate of the input-helper script). - Ignore .claude/scheduled_tasks.lock local session state. - Add .gitattributes to normalize line endings (LF in repo). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2026-07-05 20:31:01 +02:00
commit e76d88e0c7
147 changed files with 26220 additions and 0 deletions
@@ -0,0 +1,192 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { StoredArtifactRecord } from "../../src/types/storage.js";
+import { isReviewOnlyArtifactSource, resolveStoredArtifactSource } from "../../src/lib/artifactStore.js";
+import type { ArtifactStoreLoadResult, ArtifactStoreRepositoryPort, ArtifactStoreSaveResult } from "./contracts.js";
+interface ArtifactStoreFile {
+  version?: number;
+  artifacts?: StoredArtifactRecord[];
+}
+
+export class JsonArtifactStoreRepository implements ArtifactStoreRepositoryPort {
+  private readonly filePath: string;
+
+  constructor(userDataPath: string, fileName = "artifact-store.json") {
+    this.filePath = path.join(userDataPath, fileName);
+  }
+
+  async loadAll(): Promise<ArtifactStoreLoadResult> {
+    const records = await this.loadMap();
+    const artifacts = [...records.values()].sort((a, b) => (b.lastSeenAt ?? "").localeCompare(a.lastSeenAt ?? ""));
+    return { ok: true, artifacts, total: artifacts.length, path: this.filePath };
+  }
+
+  async loadMap(): Promise<Map<string, StoredArtifactRecord>> {
+    try {
+      const raw = JSON.parse(await fs.readFile(this.filePath, "utf8")) as ArtifactStoreFile;
+      const records = Array.isArray(raw.artifacts) ? raw.artifacts : [];
+      const cleaned = records
+        .filter((record) => record?.id && !isObviousGarbageRecord(record))
+        .map((record) => normalizeStoredArtifactRecordForLoad(record));
+      const store = new Map(cleaned.map((record) => [record.id, record]));
+      const storeChanged = cleaned.length !== records.length || cleaned.some((record, index) => JSON.stringify(record) !== JSON.stringify(records[index]));
+      if (storeChanged) await this.writeRecords([...store.values()]);
+      return store;
+    } catch {
+      return new Map();
+    }
+  }
+
+  async saveMany(records: StoredArtifactRecord[]): Promise<ArtifactStoreSaveResult> {
+    const store = await this.loadMap();
+    const now = new Date().toISOString();
+    let added = 0;
+    let updated = 0;
+
+    for (const record of records ?? []) {
+      if (!record?.id || isObviousGarbageRecord(record)) continue;
+      const existing = store.get(record.id);
+      if (existing) {
+        store.set(record.id, {
+          ...existing,
+          ...record,
+          firstSeenAt: existing.firstSeenAt ?? now,
+          lastSeenAt: now,
+          timesSeen: (existing.timesSeen ?? 1) + 1,
+          confidence: Math.max(existing.confidence ?? 0, record.confidence ?? 0),
+          // A later confident scan clears the review flag; an uncertain rescan
+          // must not downgrade an already confirmed artifact.
+          needsReview: Boolean(existing.needsReview) && Boolean(record.needsReview),
+          source: resolveStoredArtifactSource(existing.source, record.source),
+        });
+        updated++;
+      } else {
+        const mergeCandidate = [...store.values()].find((candidate) => shouldMergeArtifactRecords(candidate, record));
+        if (mergeCandidate) {
+          const merged = mergeArtifactRecords(mergeCandidate, record, now);
+          if (mergeCandidate.id !== merged.id) store.delete(mergeCandidate.id);
+          store.set(merged.id, merged);
+          updated++;
+        } else {
+          store.set(record.id, { ...record, firstSeenAt: now, lastSeenAt: now, timesSeen: 1 });
+          added++;
+        }
+      }
+    }
+
+    await this.writeRecords([...store.values()]);
+    return { ok: true, added, updated, total: store.size, path: this.filePath };
+  }
+
+  private async writeRecords(records: StoredArtifactRecord[]) {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify({ version: 1, artifacts: records }, null, 2), "utf8");
+  }
+}
+
+function artifactMergeKey(record: StoredArtifactRecord) {
+  return [record.name, record.slot, record.setName, record.mainStat, record.mainValue, record.level ?? ""]
+    .map((value) => `${value ?? ""}`.trim().toLowerCase())
+    .join("::");
+}
+
+function artifactFamilyKey(record: StoredArtifactRecord) {
+  return [record.name, record.slot, record.setName, record.mainStat]
+    .map((value) => `${value ?? ""}`.trim().toLowerCase())
+    .join("::");
+}
+
+function artifactQualityScore(record: StoredArtifactRecord) {
+  const corePenalty =
+    (record.name === "Unknown artifact" ? 40 : 0)
+    + (record.slot === "Unknown slot" ? 35 : 0)
+    + (record.setName === "Unknown set" ? 35 : 0)
+    + (record.mainStat === "Unknown main stat" ? 40 : 0)
+    + (record.mainValue === "?" ? 20 : 0);
+
+  return (record.confidence ?? 0)
+    + Math.min(20, (record.substats?.length ?? 0) * 5)
+    + (record.needsReview ? -12 : 8)
+    + (record.equipped && record.equipped !== "Not detected" ? 2 : 0)
+    - corePenalty;
+}
+
+function isObviousGarbageRecord(record: StoredArtifactRecord) {
+  return (
+    !record?.id
+    || record.name === "Unknown artifact"
+    || record.slot === "Unknown slot"
+    || record.setName === "Unknown set"
+    || record.mainStat === "Unknown main stat"
+    || record.mainValue === "?"
+    || (record.substats?.length ?? 0) === 0
+    || (record.confidence ?? 0) < 30
+  );
+}
+
+function parseArtifactNumericValue(value: string) {
+  const numeric = Number.parseFloat(String(value ?? "").replace(/,/g, "").replace("%", "").trim());
+  return Number.isFinite(numeric) ? numeric : 0;
+}
+
+function normalizeStoredArtifactRecordForLoad(record: StoredArtifactRecord) {
+  const normalizedTimesSeen = Math.max(1, Math.round(record.timesSeen ?? 1));
+  const reviewOnly = isReviewOnlyArtifactSource(record.source);
+  return {
+    ...record,
+    timesSeen: reviewOnly ? 1 : normalizedTimesSeen,
+    firstSeenAt: record.firstSeenAt ?? record.lastSeenAt,
+  };
+}
+
+function shouldMergeArtifactRecords(existing: StoredArtifactRecord, incoming: StoredArtifactRecord) {
+  if (existing.id === incoming.id) return true;
+
+  const overlap = (incoming.substats ?? []).filter((substat: string) => (existing.substats ?? []).includes(substat)).length;
+  const overlapThreshold = Math.min(2, Math.min(existing.substats?.length ?? 0, incoming.substats?.length ?? 0));
+  const qualityGap = Math.abs(artifactQualityScore(existing) - artifactQualityScore(incoming)) >= 8;
+
+  if (artifactMergeKey(existing) === artifactMergeKey(incoming)) {
+    return (
+      overlap >= overlapThreshold
+      || existing.needsReview
+      || incoming.needsReview
+      || (existing.substats?.length ?? 0) !== (incoming.substats?.length ?? 0)
+      || qualityGap
+    );
+  }
+
+  if (artifactFamilyKey(existing) !== artifactFamilyKey(incoming)) return false;
+
+  const sameOrBetterLevel = (incoming.level ?? 0) >= (existing.level ?? 0);
+  const sameOrBetterMainValue = parseArtifactNumericValue(incoming.mainValue) >= parseArtifactNumericValue(existing.mainValue);
+  return sameOrBetterLevel && sameOrBetterMainValue && (
+    overlap >= overlapThreshold
+    || existing.needsReview
+    || incoming.needsReview
+    || (existing.substats?.length ?? 0) !== (incoming.substats?.length ?? 0)
+    || qualityGap
+  );
+}
+
+function mergeArtifactRecords(existing: StoredArtifactRecord, incoming: StoredArtifactRecord, now: string): StoredArtifactRecord {
+  const incomingPreferred = artifactQualityScore(incoming) >= artifactQualityScore(existing);
+  const preferred = incomingPreferred ? incoming : existing;
+  const secondary = incomingPreferred ? existing : incoming;
+  const preferredSubstats = (preferred.substats?.length ?? 0) >= (secondary.substats?.length ?? 0) ? preferred.substats : secondary.substats;
+
+  return {
+    ...secondary,
+    ...preferred,
+    id: incomingPreferred ? incoming.id : existing.id,
+    level: Math.max(existing.level ?? 0, incoming.level ?? 0),
+    substats: [...(preferredSubstats ?? [])],
+    equipped: preferred.equipped && preferred.equipped !== "Not detected" ? preferred.equipped : secondary.equipped,
+    confidence: Math.max(existing.confidence ?? 0, incoming.confidence ?? 0),
+    needsReview: Boolean(existing.needsReview) && Boolean(incoming.needsReview),
+    source: resolveStoredArtifactSource(existing.source, incoming.source),
+    firstSeenAt: existing.firstSeenAt ?? now,
+    lastSeenAt: now,
+    timesSeen: (existing.timesSeen ?? 1) + 1,
+  };
+}