hoi4-agent-tools 3.0.9 → 3.2.0

package/dist/hoi4_agent_tools/decision/source-inventory.js

@@ -0,0 +1,182 @@
+import { compareCodeUnits } from '../core/canonical.js';
+import { assignments, parseClausewitz, } from '../core/source/index.js';
+export const decisionFieldNames = [
+    'allowed',
+    'visible',
+    'available',
+    'targets',
+    'target_array',
+    'state_trigger',
+    'target_root_trigger',
+    'target_trigger',
+    'cost',
+    'custom_cost_trigger',
+    'custom_cost_text',
+    'complete_effect',
+    'fire_only_once',
+    'days_re_enable',
+    'days_remove',
+    'remove_trigger',
+    'remove_effect',
+    'cancel_trigger',
+    'cancel_if_not_visible',
+    'cancel_effect',
+    'days_mission_timeout',
+    'timeout_effect',
+    'activation',
+    'selectable_mission',
+    'ai_will_do',
+];
+/** Static targeting declarations; scenario evaluation determines whether a target qualifies. */
+export function decisionTargetCatalog(source) {
+    const explicitTargets = source.fields.targets.flatMap((assignment) => {
+        if (assignment.value.type !== 'block')
+            return [];
+        return [
+            ...assignment.value.entries
+                .filter((entry) => entry.type === 'scalar')
+                .map((entry) => entry.value),
+            ...assignments(assignment.value, 'state')
+                .filter((entry) => entry.value.type === 'scalar')
+                .map((entry) => entry.value.value),
+        ];
+    });
+    const targetArrays = source.fields.target_array.flatMap((assignment) => assignment.value.type === 'scalar' ? [assignment.value.value] : []);
+    const stateFilters = source.fields.state_trigger.flatMap((assignment) => assignment.value.type === 'scalar' ? [assignment.value.value] : []);
+    const hasTargetRootTrigger = source.fields.target_root_trigger.length > 0;
+    const hasTargetTrigger = source.fields.target_trigger.length > 0;
+    return {
+        targeted: explicitTargets.length > 0 ||
+            targetArrays.length > 0 ||
+            stateFilters.some((filter) => filter !== 'no') ||
+            hasTargetRootTrigger ||
+            hasTargetTrigger,
+        explicitTargets,
+        targetArrays,
+        stateFilters,
+        hasTargetRootTrigger,
+        hasTargetTrigger,
+    };
+}
+function fields(block) {
+    return Object.fromEntries(decisionFieldNames.map((name) => [name, assignments(block, name)]));
+}
+function sourceDocument(file, documents) {
+    if (file === undefined)
+        return undefined;
+    const existing = documents.get(file.displayPath);
+    if (existing !== undefined)
+        return existing;
+    const parsed = parseClausewitz(file.bytes, file.displayPath);
+    documents.set(file.displayPath, parsed);
+    return parsed;
+}
+function categoryBlock(document, id) {
+    return assignments(document.root, id).find((assignment) => assignment.value.type === 'block')
+        ?.value;
+}
+function sourceOrder(left, right) {
+    return (compareCodeUnits(left.id, right.id) ||
+        right.loadOrder - left.loadOrder ||
+        compareCodeUnits(left.path, right.path));
+}
+/** Reuses the shared index's active/overridden selection and source inventory. */
+export function decisionSourceInventory(snapshot) {
+    const files = new Map(snapshot.files.map((file) => [file.displayPath, file]));
+    const documents = new Map();
+    const unresolvedDefinitions = [];
+    const categories = [];
+    const decisions = [];
+    const overrides = [
+        ...snapshot.index.findAll('decision_category'),
+        ...snapshot.index.findAll('decision'),
+    ]
+        .filter(({ overridden }) => overridden)
+        .sort(sourceOrder)
+        .map(({ kind, id, path, rootKind, loadOrder, location, sourceShadowed }) => ({
+        kind,
+        id,
+        path,
+        rootKind,
+        loadOrder,
+        ...(location === undefined ? {} : { location }),
+        sourceShadowed,
+    }));
+    for (const symbol of snapshot.index
+        .findAll('decision_category')
+        .filter(({ overridden }) => !overridden)
+        .sort(sourceOrder)) {
+        const file = files.get(symbol.path);
+        const document = sourceDocument(file, documents);
+        const block = document === undefined ? undefined : categoryBlock(document, symbol.id);
+        if (file === undefined || document === undefined || block === undefined) {
+            unresolvedDefinitions.push({
+                kind: 'decision_category',
+                id: symbol.id,
+                path: symbol.path,
+                reason: 'Active category index entry could not be matched to a source block',
+            });
+            continue;
+        }
+        categories.push({
+            id: symbol.id,
+            path: symbol.path,
+            rootKind: file.rootKind,
+            loadOrder: file.loadOrder,
+            sourceHash: file.sha256,
+            ...(symbol.location === undefined ? {} : { location: symbol.location }),
+            document,
+            block,
+            fields: fields(block),
+        });
+    }
+    for (const symbol of snapshot.index
+        .findAll('decision')
+        .filter(({ overridden }) => !overridden)
+        .sort(sourceOrder)) {
+        const category = typeof symbol.metadata.category === 'string' ? symbol.metadata.category : undefined;
+        const file = files.get(symbol.path);
+        const document = sourceDocument(file, documents);
+        const categoryNode = document === undefined || category === undefined
+            ? undefined
+            : categoryBlock(document, category);
+        const decisionNode = categoryNode === undefined
+            ? undefined
+            : assignments(categoryNode, symbol.id).find((assignment) => assignment.value.type === 'block')?.value;
+        if (file === undefined ||
+            document === undefined ||
+            category === undefined ||
+            decisionNode?.type !== 'block') {
+            unresolvedDefinitions.push({
+                kind: 'decision',
+                id: symbol.id,
+                path: symbol.path,
+                reason: 'Active decision index entry could not be matched to a source block',
+            });
+            continue;
+        }
+        const decisionFields = fields(decisionNode);
+        decisions.push({
+            id: symbol.id,
+            category,
+            kind: decisionFields.days_mission_timeout.length > 0 ? 'mission' : 'decision',
+            path: symbol.path,
+            rootKind: file.rootKind,
+            loadOrder: file.loadOrder,
+            sourceHash: file.sha256,
+            ...(symbol.location === undefined ? {} : { location: symbol.location }),
+            document,
+            block: decisionNode,
+            fields: decisionFields,
+        });
+    }
+    return {
+        sourceRevision: snapshot.revision,
+        complete: snapshot.complete && unresolvedDefinitions.length === 0,
+        skippedSourceCount: snapshot.skippedSourceCount,
+        decisions,
+        categories,
+        overrides,
+        unresolvedDefinitions,
+    };
+}