feat(scanner): add native artifact pipeline
Add native IK-style capture processing, Artifact Inventory, explicit promotion and single-result review. Confirm the three live OCR corrections in the eval corpus and preserve extraction/value separation.
This commit is contained in:
AzuTear
@@ -0,0 +1,357 @@
|
||||
import fs from "node:fs/promises";
|
||||
import path from "node:path";
|
||||
import { reviewedMainValueError, type ParsedArtifactCandidate } from "../../src/lib/artifactOcrParser.js";
|
||||
import { matchParsedArtifactToIk, type IkArtifactCatalog } from "../../src/lib/ikArtifactMatcher.js";
|
||||
import { buildScanResultPromotionSummary, scanResultToStoredArtifact } from "../../src/lib/scanResultPromotion.js";
|
||||
import { implausibleSubstats } from "../../src/lib/substatRolls.js";
|
||||
import type {
|
||||
ArtifactStoreLoadResult,
|
||||
ArtifactStoreSaveResult,
|
||||
NativeScannerPromotionStatus,
|
||||
NativeScannerReviewArtifactInput,
|
||||
NativeScannerReviewStatus,
|
||||
ReviewSamplePayload,
|
||||
} from "../../src/types/global.js";
|
||||
import type { StoredArtifactRecord, StoredScanResultEntry } from "../../src/types/storage.js";
|
||||
|
||||
export interface NativeScannerResultWorkflowDependencies {
|
||||
resolveRunDir(runDir?: string): string;
|
||||
loadArtifacts?: () => Promise<ArtifactStoreLoadResult>;
|
||||
saveArtifacts(records: StoredArtifactRecord[]): Promise<Pick<ArtifactStoreSaveResult, "added" | "updated"> & Partial<ArtifactStoreSaveResult>>;
|
||||
saveReviewSample?: (sample: ReviewSamplePayload) => Promise<{ ok: boolean }>;
|
||||
loadIkArtifactCatalog?: () => Promise<IkArtifactCatalog | null>;
|
||||
}
|
||||
|
||||
export interface NativeScannerResultWorkflowService {
|
||||
promoteResults(options: { runDir?: string; resultIds: string[] }): Promise<NativeScannerPromotionStatus>;
|
||||
reviewResult(options: {
|
||||
runDir?: string;
|
||||
resultId: string;
|
||||
action: "approve" | "reject";
|
||||
artifact?: NativeScannerReviewArtifactInput;
|
||||
note?: string;
|
||||
}): Promise<NativeScannerReviewStatus>;
|
||||
}
|
||||
|
||||
export function createNativeScannerResultWorkflowService(
|
||||
deps: NativeScannerResultWorkflowDependencies,
|
||||
): NativeScannerResultWorkflowService {
|
||||
return {
|
||||
async promoteResults(options) {
|
||||
const runDir = deps.resolveRunDir(options.runDir);
|
||||
const logPath = runDir ? path.join(runDir, "promotion-log.jsonl") : "";
|
||||
const requestedIds = [...new Set((options.resultIds ?? []).filter((id) => typeof id === "string" && id.trim()))];
|
||||
if (!runDir || requestedIds.length === 0 || !deps.loadArtifacts) {
|
||||
return emptyPromotionStatus(runDir, logPath, requestedIds.length, "Promotion requires a run directory, selected result IDs, and artifact-store access.");
|
||||
}
|
||||
|
||||
try {
|
||||
const { path: resultsPath, results: scanResults } = await loadScanResults(runDir);
|
||||
const selectedIds = new Set(requestedIds);
|
||||
const selectedResults = scanResults.filter((entry) => selectedIds.has(entry.id));
|
||||
const store = await deps.loadArtifacts();
|
||||
if (!store.ok) return emptyPromotionStatus(runDir, logPath, requestedIds.length, "Artifact store could not be loaded.");
|
||||
|
||||
const summary = buildScanResultPromotionSummary(selectedResults, store.artifacts);
|
||||
const readyIds = new Set(summary.decisions.filter((decision) => decision.canPersist).map((decision) => decision.resultId));
|
||||
const records = selectedResults
|
||||
.filter((entry) => readyIds.has(entry.id))
|
||||
.map(scanResultToStoredArtifact)
|
||||
.filter((record): record is StoredArtifactRecord => Boolean(record));
|
||||
const saved = records.length > 0
|
||||
? await deps.saveArtifacts(records)
|
||||
: { ok: true, added: 0, updated: 0, total: store.total, path: store.path };
|
||||
if (saved.ok === false) return emptyPromotionStatus(runDir, logPath, requestedIds.length, "Artifact store write failed.");
|
||||
|
||||
const recordIdByResultId = new Map(selectedResults.map((entry) => [entry.id, scanResultToStoredArtifact(entry)?.id]));
|
||||
const promotedResultIds = selectedResults.filter((entry) => readyIds.has(entry.id)).map((entry) => entry.id);
|
||||
const promotedSet = new Set(promotedResultIds);
|
||||
const updatedResults = scanResults.map((entry) => promotedSet.has(entry.id)
|
||||
? { ...entry, artifactRecordId: recordIdByResultId.get(entry.id), persistedArtifact: true }
|
||||
: entry);
|
||||
await writeScanResults(resultsPath, updatedResults);
|
||||
|
||||
const status: NativeScannerPromotionStatus = {
|
||||
ok: true,
|
||||
runDir,
|
||||
logPath,
|
||||
requested: requestedIds.length,
|
||||
selected: selectedResults.length,
|
||||
promoted: promotedResultIds.length,
|
||||
alreadyStored: summary.alreadyStored + summary.persisted,
|
||||
review: summary.review,
|
||||
blocked: summary.blocked + Math.max(0, requestedIds.length - selectedResults.length),
|
||||
added: saved.added,
|
||||
updated: saved.updated,
|
||||
total: saved.total ?? store.total,
|
||||
promotedResultIds,
|
||||
};
|
||||
await appendWorkflowLog(logPath, { at: new Date().toISOString(), ...status });
|
||||
return status;
|
||||
} catch (error) {
|
||||
return emptyPromotionStatus(runDir, logPath, requestedIds.length, errorMessage(error));
|
||||
}
|
||||
},
|
||||
|
||||
async reviewResult(options) {
|
||||
const runDir = deps.resolveRunDir(options.runDir);
|
||||
const logPath = runDir ? path.join(runDir, "review-log.jsonl") : "";
|
||||
const resultId = String(options.resultId ?? "").trim();
|
||||
if (!runDir || !resultId || !["approve", "reject"].includes(options.action)) {
|
||||
return emptyReviewStatus(runDir, logPath, resultId, options.action, "Review requires a run directory, result ID, and valid action.");
|
||||
}
|
||||
|
||||
try {
|
||||
const { path: resultsPath, results: scanResults } = await loadScanResults(runDir);
|
||||
const index = scanResults.findIndex((entry) => entry.id === resultId);
|
||||
if (index < 0) return emptyReviewStatus(runDir, logPath, resultId, options.action, "Selected scan result was not found.");
|
||||
const current = scanResults[index];
|
||||
if (current.persistedArtifact) return emptyReviewStatus(runDir, logPath, resultId, options.action, "Persisted results cannot be edited through review.");
|
||||
|
||||
const reviewedAt = new Date().toISOString();
|
||||
const note = String(options.note ?? "").trim().slice(0, 500);
|
||||
let correctedFields: string[] = [];
|
||||
let evalSampleSaved = false;
|
||||
let updated: StoredScanResultEntry;
|
||||
|
||||
if (options.action === "reject") {
|
||||
updated = rejectResult(current, reviewedAt, note);
|
||||
} else {
|
||||
const artifact = normalizeReviewedArtifact(options.artifact);
|
||||
const errors = reviewedArtifactErrors(artifact);
|
||||
if (errors.length > 0) return emptyReviewStatus(runDir, logPath, resultId, options.action, errors.join(" "));
|
||||
const parsed = reviewedArtifactToParsed(artifact);
|
||||
const catalog = deps.loadIkArtifactCatalog ? await deps.loadIkArtifactCatalog() : null;
|
||||
const ikMatch = matchParsedArtifactToIk(parsed, catalog);
|
||||
if (!ikMatch?.matched) {
|
||||
return emptyReviewStatus(runDir, logPath, resultId, options.action, `IK validation failed: ${ikMatch?.notes.join(" ") || "catalog unavailable"}`);
|
||||
}
|
||||
correctedFields = artifactChangedFields(current.artifact, artifact);
|
||||
updated = approveResult(current, artifact, ikMatch, reviewedAt, note, correctedFields);
|
||||
evalSampleSaved = await saveApprovedEvalSample(deps, runDir, current, artifact, parsed);
|
||||
}
|
||||
|
||||
scanResults[index] = updated;
|
||||
await writeScanResults(resultsPath, scanResults);
|
||||
const status: NativeScannerReviewStatus = {
|
||||
ok: true,
|
||||
runDir,
|
||||
logPath,
|
||||
resultId,
|
||||
action: options.action,
|
||||
evalSampleSaved,
|
||||
correctedFields,
|
||||
};
|
||||
await appendWorkflowLog(logPath, { at: reviewedAt, ...status, note });
|
||||
return status;
|
||||
} catch (error) {
|
||||
return emptyReviewStatus(runDir, logPath, resultId, options.action, errorMessage(error));
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
async function loadScanResults(runDir: string) {
|
||||
const resultsPath = path.join(runDir, "scan-results.json");
|
||||
const raw = JSON.parse(await fs.readFile(resultsPath, "utf8"));
|
||||
const results = Array.isArray(raw) ? raw.filter(isStoredScanResultEntry) : [];
|
||||
return { path: resultsPath, results };
|
||||
}
|
||||
|
||||
async function writeScanResults(resultsPath: string, results: StoredScanResultEntry[]) {
|
||||
await fs.writeFile(resultsPath, JSON.stringify(results, null, 2), "utf8");
|
||||
}
|
||||
|
||||
async function appendWorkflowLog(logPath: string, payload: object) {
|
||||
await fs.appendFile(logPath, `${JSON.stringify(payload)}\n`, "utf8");
|
||||
}
|
||||
|
||||
function rejectResult(current: StoredScanResultEntry, reviewedAt: string, note: string): StoredScanResultEntry {
|
||||
return {
|
||||
...current,
|
||||
extractionStatus: "review",
|
||||
needsReview: true,
|
||||
valueStatus: "review",
|
||||
notes: [...new Set([...current.notes, note || "Manual review rejected this result."])],
|
||||
review: { status: "rejected", reviewedAt, note: note || undefined, correctedFields: [] },
|
||||
};
|
||||
}
|
||||
|
||||
function approveResult(
|
||||
current: StoredScanResultEntry,
|
||||
artifact: NativeScannerReviewArtifactInput,
|
||||
ikMatch: NonNullable<StoredScanResultEntry["ikMatch"]>,
|
||||
reviewedAt: string,
|
||||
note: string,
|
||||
correctedFields: string[],
|
||||
): StoredScanResultEntry {
|
||||
return {
|
||||
...current,
|
||||
extractionStatus: "parsed",
|
||||
extractionConfidence: 100,
|
||||
needsReview: false,
|
||||
valueStatus: "deferred",
|
||||
valueScore: null,
|
||||
artifact,
|
||||
ikMatch,
|
||||
fieldConfidences: reviewedFieldConfidences(artifact),
|
||||
artifactRecordId: undefined,
|
||||
persistedArtifact: false,
|
||||
notes: note ? [`Manual review approved: ${note}`] : ["Manual review approved."],
|
||||
error: undefined,
|
||||
review: { status: "approved", reviewedAt, note: note || undefined, correctedFields },
|
||||
};
|
||||
}
|
||||
|
||||
async function saveApprovedEvalSample(
|
||||
deps: NativeScannerResultWorkflowDependencies,
|
||||
runDir: string,
|
||||
current: StoredScanResultEntry,
|
||||
artifact: NativeScannerReviewArtifactInput,
|
||||
parsed: ParsedArtifactCandidate,
|
||||
) {
|
||||
if (!deps.saveReviewSample) return false;
|
||||
const ocr = await loadReviewOcr(runDir, current.sequence);
|
||||
if (ocr.length === 0) return false;
|
||||
const saved = await deps.saveReviewSample({
|
||||
reason: "native-review-approved",
|
||||
parsed,
|
||||
capture: {
|
||||
id: `${current.runId}:${current.sequence}`,
|
||||
name: current.imagePath,
|
||||
width: 492,
|
||||
height: 838,
|
||||
capturedAt: current.capturedAt,
|
||||
locked: artifact.locked,
|
||||
ocr,
|
||||
},
|
||||
});
|
||||
return Boolean(saved.ok);
|
||||
}
|
||||
|
||||
function emptyPromotionStatus(runDir: string, logPath: string, requested: number, error: string): NativeScannerPromotionStatus {
|
||||
return {
|
||||
ok: false,
|
||||
runDir,
|
||||
logPath,
|
||||
requested,
|
||||
selected: 0,
|
||||
promoted: 0,
|
||||
alreadyStored: 0,
|
||||
review: 0,
|
||||
blocked: requested,
|
||||
added: 0,
|
||||
updated: 0,
|
||||
total: 0,
|
||||
promotedResultIds: [],
|
||||
error,
|
||||
};
|
||||
}
|
||||
|
||||
function emptyReviewStatus(
|
||||
runDir: string,
|
||||
logPath: string,
|
||||
resultId: string,
|
||||
action: "approve" | "reject",
|
||||
error: string,
|
||||
): NativeScannerReviewStatus {
|
||||
return { ok: false, runDir, logPath, resultId, action, evalSampleSaved: false, correctedFields: [], error };
|
||||
}
|
||||
|
||||
function normalizeReviewedArtifact(input?: NativeScannerReviewArtifactInput): NativeScannerReviewArtifactInput {
|
||||
return {
|
||||
name: String(input?.name ?? "").trim(),
|
||||
slot: String(input?.slot ?? "").trim(),
|
||||
level: Math.round(Number(input?.level ?? -1)),
|
||||
setName: String(input?.setName ?? "").trim(),
|
||||
mainStat: String(input?.mainStat ?? "").trim(),
|
||||
mainValue: String(input?.mainValue ?? "").trim(),
|
||||
substats: [...new Set((input?.substats ?? []).map((entry) => String(entry).trim()).filter(Boolean))].slice(0, 4),
|
||||
equipped: String(input?.equipped ?? "Not detected").trim() || "Not detected",
|
||||
locked: typeof input?.locked === "boolean" ? input.locked : undefined,
|
||||
};
|
||||
}
|
||||
|
||||
function reviewedArtifactErrors(artifact: NativeScannerReviewArtifactInput) {
|
||||
const errors: string[] = [];
|
||||
if (!artifact.name || artifact.name === "Unknown artifact") errors.push("Artifact name is required.");
|
||||
if (!artifact.slot || artifact.slot === "Unknown slot") errors.push("Artifact slot is required.");
|
||||
if (!artifact.setName || artifact.setName === "Unknown set") errors.push("Artifact set is required.");
|
||||
if (!artifact.mainStat || artifact.mainStat === "Unknown main stat") errors.push("Main stat is required.");
|
||||
if (!artifact.mainValue || artifact.mainValue === "?") errors.push("Main value is required.");
|
||||
if (!Number.isInteger(artifact.level) || artifact.level < 0 || artifact.level > 20) errors.push("Level must be between 0 and 20.");
|
||||
if (artifact.substats.length === 0) errors.push("At least one substat is required.");
|
||||
const mainValueError = reviewedMainValueError(artifact.slot, artifact.mainStat, artifact.level, artifact.mainValue);
|
||||
if (mainValueError) errors.push(mainValueError);
|
||||
const implausible = implausibleSubstats(artifact.substats, artifact.level > 16 ? 5 : undefined);
|
||||
if (implausible.length > 0) errors.push(`Implausible substats: ${implausible.join(", ")}.`);
|
||||
return errors;
|
||||
}
|
||||
|
||||
function reviewedArtifactToParsed(artifact: NativeScannerReviewArtifactInput): ParsedArtifactCandidate {
|
||||
const manual = (value: string) => ({ value, confidence: 100, source: "database" as const });
|
||||
return {
|
||||
...artifact,
|
||||
confidence: 100,
|
||||
notes: ["Manually reviewed and approved."],
|
||||
fields: {
|
||||
name: manual(artifact.name),
|
||||
slot: manual(artifact.slot),
|
||||
level: manual(String(artifact.level)),
|
||||
mainStat: manual(artifact.mainStat),
|
||||
mainValue: manual(artifact.mainValue),
|
||||
setName: manual(artifact.setName),
|
||||
equipped: manual(artifact.equipped),
|
||||
substats: manual(artifact.substats.join(", ")),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function artifactChangedFields(
|
||||
before: StoredScanResultEntry["artifact"],
|
||||
after: NativeScannerReviewArtifactInput,
|
||||
) {
|
||||
if (!before) return ["name", "slot", "level", "setName", "mainStat", "mainValue", "substats", "equipped", "locked"];
|
||||
return (["name", "slot", "level", "setName", "mainStat", "mainValue", "substats", "equipped", "locked"] as const)
|
||||
.filter((key) => JSON.stringify(before[key]) !== JSON.stringify(after[key]));
|
||||
}
|
||||
|
||||
function reviewedFieldConfidences(artifact: NativeScannerReviewArtifactInput) {
|
||||
return [
|
||||
{ key: "name", label: "Name", value: artifact.name },
|
||||
{ key: "slot", label: "Slot", value: artifact.slot },
|
||||
{ key: "level", label: "Level", value: String(artifact.level) },
|
||||
{ key: "mainStat", label: "Main stat", value: artifact.mainStat },
|
||||
{ key: "mainValue", label: "Main value", value: artifact.mainValue },
|
||||
{ key: "setName", label: "Set", value: artifact.setName },
|
||||
{ key: "equipped", label: "Equipped", value: artifact.equipped },
|
||||
{ key: "substats", label: "Substats", value: artifact.substats.join(", ") },
|
||||
].map((field) => ({ ...field, confidence: 100, source: "database" as const }));
|
||||
}
|
||||
|
||||
async function loadReviewOcr(runDir: string, sequence: number) {
|
||||
try {
|
||||
const report = JSON.parse(await fs.readFile(path.join(runDir, "processing-report.json"), "utf8"));
|
||||
const result = Array.isArray(report?.results) ? report.results.find((entry: { sequence?: number }) => entry.sequence === sequence) : null;
|
||||
return Array.isArray(result?.ocr) ? result.ocr : [];
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
function isStoredScanResultEntry(value: unknown): value is StoredScanResultEntry {
|
||||
if (!value || typeof value !== "object") return false;
|
||||
const entry = value as Partial<StoredScanResultEntry>;
|
||||
return typeof entry.id === "string"
|
||||
&& typeof entry.runId === "string"
|
||||
&& Number.isFinite(entry.sequence)
|
||||
&& typeof entry.source === "string"
|
||||
&& typeof entry.imagePath === "string"
|
||||
&& typeof entry.extractionStatus === "string"
|
||||
&& typeof entry.valueStatus === "string"
|
||||
&& Array.isArray(entry.notes);
|
||||
}
|
||||
|
||||
function errorMessage(error: unknown) {
|
||||
return error instanceof Error ? error.message : String(error);
|
||||
}
|
||||
Reference in New Issue
Block a user