hoi4-agent-tools 3.10.0 → 4.0.0

package/dist/hoi4_agent_tools/map/service.js

@@ -1,3 +1,4 @@
+import { MAP_REFERENCE_SCRIPT_PATTERNS, mapScriptConsistency } from './references.js';
 import path from 'node:path';
 import { escapeFileGlob } from '../core/file-glob.js';
 import { ArtifactStore, boundedSourceHashEvidence, publicArtifactLink, } from '../core/artifacts.js';
@@ -381,6 +382,8 @@ function sourceTextPatterns(roots) {
     return [
         'common/bookmarks/**/*.txt',
         'common/terrain/*.txt',
+        'common/buildings/*.txt',
+        'descriptor.mod',
         ...roots.map.flatMap((root) => {
             const normalized = normalizeSourceRoot(root);
             return ['map', 'csv', 'txt'].map((extension) => `${normalized}/**/*.${extension}`);
@@ -396,18 +399,24 @@ function provinceBitmapPatterns(defaultMaps, mapRoots) {
     const activeByPath = new Map(defaultMaps
         .filter(({ shadowedBy }) => shadowedBy === undefined)
         .map((file) => [file.relativePath.replaceAll('\\', '/').toLowerCase(), file]));
-    let activeName = 'provinces.bmp';
-    for (const root of mapRoots) {
-        const relativePath = `${normalizeSourceRoot(root)}/default.map`.toLowerCase();
-        const active = activeByPath.get(relativePath);
-        if (active === undefined)
-            continue;
-        activeName = defaultMapSelectorValue(active, 'provinces', activeName);
-        break;
-    }
-    const names = new Set([activeName]);
-    for (const file of defaultMaps) {
-        names.add(defaultMapSelectorValue(file, 'provinces', activeName));
+    // The province bitmap, and the heightmap that gives generated positions their height.
+    const names = new Set();
+    for (const [selector, fallback] of [
+        ['provinces', 'provinces.bmp'],
+        ['heightmap', 'heightmap.bmp'],
+    ]) {
+        let activeName = fallback;
+        for (const root of mapRoots) {
+            const relativePath = `${normalizeSourceRoot(root)}/default.map`.toLowerCase();
+            const active = activeByPath.get(relativePath);
+            if (active === undefined)
+                continue;
+            activeName = defaultMapSelectorValue(active, selector, activeName);
+            break;
+        }
+        names.add(activeName);
+        for (const file of defaultMaps)
+            names.add(defaultMapSelectorValue(file, selector, activeName));
     }
     const patterns = new Set();
     for (const root of mapRoots) {
@@ -463,6 +472,43 @@ function validationWithPlan(validation, plan) {
         checks,
     };
 }
+/**
+ * A map whose bitmap changed size (a new world) cannot be diffed pixel by pixel; its review
+ * image is the whole proposed map, and every province counts as changed.
+ */
+async function wholeMapDiff(after, options) {
+    const rendered = await renderMap(after, {
+        layer: 'state',
+        overlays: ['coastlines', 'ports', 'victory-points', 'supply-nodes', 'railways'],
+        ...(options?.scale === undefined ? {} : { scale: options.scale }),
+        ...(options?.signal === undefined ? {} : { signal: options.signal }),
+        ...(options?.budget === undefined ? {} : { budget: options.budget }),
+    });
+    return {
+        ...rendered,
+        changedProvinceIds: after.definitions.map(({ id }) => id).filter((id) => id > 0),
+        semantic: {
+            definitions: [],
+            stateMembership: [],
+            regionMembership: [],
+            states: [],
+            ports: [],
+            buildingPositions: [],
+            unitPositions: [],
+            weatherPositions: [],
+            entityLocators: [],
+            supplyNodes: [],
+            railways: [],
+            adjacencies: [],
+            normalAdjacencies: [],
+            supplyNodesChanged: true,
+            railwaysChanged: true,
+            adjacenciesChanged: true,
+            normalAdjacenciesChanged: true,
+        },
+        ...(options?.review === undefined ? {} : { review: options.review }),
+    };
+}
 export class AgentNudger {
     engine;
     resolver;
@@ -497,17 +543,7 @@ export class AgentNudger {
         const locatorSnapshot = await this.engine.scan(workspaceId, { patterns: ['**/*.asset'], rootKinds: ['mod', 'fixture'] }, principal, signal);
         const externalScriptSnapshot = includeExternalScriptReferences
             ? await this.engine.scan(workspaceId, {
-                patterns: [
-                    'events/**/*.txt',
-                    'common/national_focus/**/*.txt',
-                    'common/decisions/**/*.txt',
-                    'common/scripted_effects/**/*.txt',
-                    'common/scripted_triggers/**/*.txt',
-                    'common/on_actions/**/*.txt',
-                    'common/ideas/**/*.txt',
-                    'common/characters/**/*.txt',
-                    'history/countries/**/*.txt',
-                ],
+                patterns: [...MAP_REFERENCE_SCRIPT_PATTERNS],
             }, principal, signal)
             : undefined;
         signal?.throwIfAborted();
@@ -524,20 +560,43 @@ export class AgentNudger {
             index: MapWorkspaceIndex.build(files, sourceRoots, SymbolIndex.build(files)),
         };
     }
-    async validate(workspaceId, principal, signal) {
-        const snapshot = await this.scan(workspaceId, principal, signal);
+    async validate(workspaceId, principal, signal, scripts = false) {
+        const snapshot = await this.scan(workspaceId, principal, signal, scripts);
+        const validation = await validateMapAsync(snapshot.index, signal === undefined ? {} : { signal });
+        if (!scripts)
+            return { snapshot, validation };
+        const consistency = mapScriptConsistency(snapshot.index);
+        const diagnostics = sortDiagnostics([...validation.diagnostics, ...consistency.diagnostics]);
         return {
             snapshot,
-            validation: await validateMapAsync(snapshot.index, signal === undefined ? {} : { signal }),
+            validation: {
+                ...validation,
+                passed: validation.passed &&
+                    !consistency.diagnostics.some(({ severity }) => severity === 'error'),
+                diagnostics,
+                checks: [
+                    ...validation.checks,
+                    {
+                        id: 'map-script-references',
+                        passed: consistency.missing === 0,
+                        message: `${consistency.references} script reference(s) to map entities checked; ${consistency.missing} name an undefined state, province or region`,
+                    },
+                ],
+            },
+            scriptReferences: { references: consistency.references, missing: consistency.missing },
         };
     }
     async prepareOperations(workspaceId, operations, principal, signal) {
         signal?.throwIfAborted();
-        const snapshot = await this.scan(workspaceId, principal, signal, operations.some(({ kind }) => kind === 'renumber_map_entity'));
+        const snapshot = await this.scan(workspaceId, principal, signal, operations.some((operation) => operation.kind === 'renumber_map_entity' ||
+            operation.kind === 'remap_map_references' ||
+            'remapReferences' in operation));
         const plan = await planMapOperationsAsync(snapshot.index, operations, signal);
         const baselineValidation = await validateMapAsync(snapshot.index, signal === undefined ? {} : { signal });
+        // A new world has nothing to compare its bitmap format and pixels with.
+        const newWorld = operations.some(({ kind }) => kind === 'create_world');
         const rawValidation = await validateMapAsync(plan.finalIndex, {
-            baseline: snapshot.index,
+            ...(newWorld ? {} : { baseline: snapshot.index }),
             ...(signal === undefined ? {} : { signal }),
             ...(plan.expectedChangedBounds === undefined
                 ? {}
@@ -739,20 +798,35 @@ export class AgentNudger {
             'victory-points',
             'weather-positions',
         ];
+        const hasBeforeMap = snapshot.index.raster !== undefined ||
+            snapshot.index.diagnostics.some(({ code }) => code.startsWith('RENDER_'));
+        const sameSize = snapshot.index.provinceBitmap !== undefined &&
+            snapshot.index.provinceBitmap.width === plan.finalIndex.provinceBitmap?.width &&
+            snapshot.index.provinceBitmap.height === plan.finalIndex.provinceBitmap.height;
         const [rawBundle, rawBeforeBundle, rawProposedBundle] = await Promise.all([
-            renderMapDiff(snapshot.index, plan.finalIndex, {
-                ...(options.scale === undefined ? {} : { scale: options.scale }),
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-                budget,
-                review,
-            }),
-            renderMap(snapshot.index, {
-                layer: 'state',
-                overlays: [...comparisonOverlays],
-                ...(options.scale === undefined ? {} : { scale: options.scale }),
-                ...(options.signal === undefined ? {} : { signal: options.signal }),
-                budget,
-            }),
+            sameSize
+                ? renderMapDiff(snapshot.index, plan.finalIndex, {
+                    ...(options.scale === undefined ? {} : { scale: options.scale }),
+                    ...(options.signal === undefined ? {} : { signal: options.signal }),
+                    budget,
+                    review,
+                })
+                : wholeMapDiff(plan.finalIndex, {
+                    ...(options.scale === undefined ? {} : { scale: options.scale }),
+                    ...(options.signal === undefined ? {} : { signal: options.signal }),
+                    budget,
+                    review,
+                }),
+            // A new world over a game without any map has nothing to draw as "before".
+            hasBeforeMap
+                ? renderMap(snapshot.index, {
+                    layer: 'state',
+                    overlays: [...comparisonOverlays],
+                    ...(options.scale === undefined ? {} : { scale: options.scale }),
+                    ...(options.signal === undefined ? {} : { signal: options.signal }),
+                    budget,
+                })
+                : Promise.resolve(undefined),
             renderMap(plan.finalIndex, {
                 layer: 'state',
                 overlays: [...comparisonOverlays],
@@ -764,7 +838,9 @@ export class AgentNudger {
         const completeSourceHashes = sourceHashes(snapshot);
         const sourceEvidence = boundedSourceHashEvidence(completeSourceHashes);
         const bundle = mapBundleWithSourceHashes(rawBundle, completeSourceHashes);
-        const beforeBundle = mapBundleWithSourceHashes(rawBeforeBundle, completeSourceHashes);
+        const beforeBundle = rawBeforeBundle === undefined
+            ? undefined
+            : mapBundleWithSourceHashes(rawBeforeBundle, completeSourceHashes);
         const proposedBundle = mapBundleWithSourceHashes(rawProposedBundle, completeSourceHashes);
         const workspace = this.resolver.get(snapshot.workspaceId, options.principal);
         const provenance = {
@@ -816,24 +892,6 @@ export class AgentNudger {
                 content: bundle.html,
                 provenance,
             },
-            {
-                name: 'map-before.png',
-                mimeType: 'image/png',
-                content: beforeBundle.png,
-                provenance: comparisonProvenance('before'),
-            },
-            {
-                name: 'map-before.json',
-                mimeType: 'application/json',
-                content: beforeBundle.json,
-                provenance: comparisonProvenance('before'),
-            },
-            {
-                name: 'map-before.html',
-                mimeType: 'text/html',
-                content: beforeBundle.html,
-                provenance: comparisonProvenance('before'),
-            },
             {
                 name: 'map-proposed.png',
                 mimeType: 'image/png',
@@ -853,10 +911,27 @@ export class AgentNudger {
                 provenance: comparisonProvenance('proposed'),
             },
         ];
+        if (beforeBundle !== undefined)
+            writes.splice(3, 0, {
+                name: 'map-before.png',
+                mimeType: 'image/png',
+                content: beforeBundle.png,
+                provenance: comparisonProvenance('before'),
+            }, {
+                name: 'map-before.json',
+                mimeType: 'application/json',
+                content: beforeBundle.json,
+                provenance: comparisonProvenance('before'),
+            }, {
+                name: 'map-before.html',
+                mimeType: 'text/html',
+                content: beforeBundle.html,
+                provenance: comparisonProvenance('before'),
+            });
         const artifacts = await this.artifacts.withAtomicChunkedWrites(workspace, writes, (stored) => Promise.resolve([...stored]), options.signal);
         return {
             bundle,
-            beforeBundle,
+            ...(beforeBundle === undefined ? {} : { beforeBundle }),
             proposedBundle,
             plan,
             artifacts,

package/dist/hoi4_agent_tools/map/tool-operations.js

@@ -362,7 +362,7 @@ export async function inspectMap(engine, nudger, input, context) {
         await context.progress(3, 3, 'Map lookup complete');
         return result;
     }
-    const { snapshot, validation } = await nudger.validate(context.workspaceId, context.principal, context.signal);
+    const { snapshot, validation, scriptReferences } = await nudger.validate(context.workspaceId, context.principal, context.signal, input.references);
     const sharedRevision = snapshot.revision;
     const catalog = buildMapCatalog(snapshot.index);
     const queryMatches = input.query === undefined ? [] : searchMapCatalog(catalog, input.query, input.queryLimit);
@@ -522,6 +522,7 @@ export async function inspectMap(engine, nudger, input, context) {
         provinceGeometryRowRunCount: provinceGeometry?.rowRunCount ?? 0,
         unknownProvinceIds: provinceGeometry?.unknownProvinceIds ?? [],
         missingGeometryProvinceIds: provinceGeometry?.missingGeometryProvinceIds ?? [],
+        ...(scriptReferences === undefined ? {} : { scriptReferences }),
     });
     result.code = 'MAP_INSPECTED';
     setInlineFilesScanned(result, snapshot.files.map(({ displayPath }) => displayPath));

package/dist/hoi4_agent_tools/map/validation.js

@@ -546,6 +546,9 @@ function* validateDefinitions(index, diagnostics, options) {
     }
     for (const [definitionIndex, definition] of index.definitions.entries()) {
         yield* cancellationCheckpoint(options.signal, definitionIndex, 256);
+        // Province 0 is the reserved null row (0;0;0;0;land;false;unknown;0) the game expects.
+        if (definition.id === 0 && definition.terrain === 'unknown')
+            continue;
         const terrain = index.terrainCategories?.get(definition.terrain);
         if (index.terrainCategories !== undefined && terrain === undefined) {
             addDiagnostic(diagnostics, options, {