hoi4-agent-tools 3.3.0 → 3.4.0

package/dist/hoi4_agent_tools/schemas/focus-requests.js

@@ -17,6 +17,10 @@ export const focusInspectRequestSchema = z
     previous: compactFocusLayoutSchema.optional(),
     laneSpacing: z.number().int().min(1).max(100).optional(),
     nodeSpacing: z.number().int().min(1).max(100).optional(),
+    scenario: z
+        .object({ completedFocusIds: z.array(z.string().min(1).max(256)).max(10_000) })
+        .strict()
+        .optional(),
 })
     .strict()
     .superRefine((value, context) => {
@@ -34,7 +38,7 @@ export const focusInspectRequestSchema = z
             message: 'treeId is only valid in national mode',
         });
     if (mode === 'continuous') {
-        for (const field of ['previous', 'laneSpacing', 'nodeSpacing']) {
+        for (const field of ['previous', 'laneSpacing', 'nodeSpacing', 'scenario']) {
             if (value[field] !== undefined)
                 context.addIssue({
                     code: 'custom',
@@ -49,6 +53,12 @@ export const focusInspectRequestSchema = z
             path: ['previous'],
             message: 'previous requires treeId so it applies to exactly one tree',
         });
+    if (value.scenario !== undefined && value.treeId === undefined)
+        context.addIssue({
+            code: 'custom',
+            path: ['scenario'],
+            message: 'scenario requires treeId so it applies to exactly one tree',
+        });
 });
 export const focusRenderRequestSchema = z
     .object({
@@ -64,6 +74,7 @@ export const focusRenderRequestSchema = z
         .min(FOCUS_RENDER_MIN_OUTPUT_SCALE)
         .max(FOCUS_RENDER_MAX_OUTPUT_SCALE)
         .optional(),
+    cropFocusIds: z.array(z.string().min(1).max(256)).max(16).optional(),
     columns: z.number().int().min(1).max(12).optional(),
     padding: z.number().int().min(0).max(1000).optional(),
 })
@@ -80,6 +91,7 @@ export const focusRenderRequestSchema = z
             ['horizontalSpacing', value.horizontalSpacing],
             ['verticalSpacing', value.verticalSpacing],
             ['reviewScale', value.reviewScale],
+            ['cropFocusIds', value.cropFocusIds],
         ];
     for (const [field, fieldValue] of invalid) {
         if (fieldValue !== undefined)
@@ -103,6 +115,25 @@ export const focusRewriteRequestSchema = z
     relativePath: workspaceRelativePathSchema,
     treeId: z.string().min(1).max(256).optional(),
     layoutMode: z.enum(['authored', 'compact']).default('authored'),
+    compactFocusIds: z.array(z.string().min(1).max(256)).min(1).max(10_000).optional(),
+    pinnedFocusIds: z.array(z.string().min(1).max(256)).max(10_000).optional(),
+    symmetryGroups: z
+        .array(z
+        .object({
+        centerFocusId: z.string().min(1).max(256),
+        pairs: z
+            .array(z
+            .object({
+            leftFocusId: z.string().min(1).max(256),
+            rightFocusId: z.string().min(1).max(256),
+        })
+            .strict())
+            .min(1)
+            .max(10_000),
+    })
+        .strict())
+        .max(64)
+        .optional(),
     plan: compactFocusPlanSchema.optional(),
     createIfMissing: z.boolean().default(false),
     horizontalSpacing: z.number().int().min(80).max(1000).optional(),
@@ -117,6 +148,14 @@ export const focusRewriteRequestSchema = z
 })
     .strict()
     .superRefine((value, context) => {
+    if (value.layoutMode !== 'compact')
+        for (const field of ['compactFocusIds', 'pinnedFocusIds', 'symmetryGroups'])
+            if (value[field] !== undefined)
+                context.addIssue({
+                    code: 'custom',
+                    path: [field],
+                    message: `${field} requires compact layout mode`,
+                });
     const mode = value.mode ?? 'national';
     const schema = mode === 'continuous' ? continuousFocusPaletteSchema : focusTreePlanSchema;
     if (value.plan !== undefined && !schema.safeParse(value.plan).success)

package/dist/hoi4_agent_tools/schemas/gui-requests.js

@@ -82,6 +82,14 @@ export const guiRenderRequestSchema = z
     relatedScenarios: z.array(compactGuiScenarioSchema).max(32).optional(),
     generatedScenarios: compactGeneratedScenarioOptionsSchema.optional(),
     comparisonScenario: compactGuiScenarioSchema.optional(),
+    sourceBaseline: z
+        .object({
+        relativePath: workspaceRelativePathSchema,
+        source: z.string().max(SOURCE_MAX_BYTES),
+    })
+        .strict()
+        .optional()
+        .describe('Previous mod-owned .gui source for a matched source comparison using the requested scenario.'),
 })
     .strict()
     .superRefine(({ scenario, states, resolutions, relatedScenarios, generatedScenarios }, context) => {

package/dist/hoi4_agent_tools/schemas/map-requests.js

@@ -63,6 +63,7 @@ export const mapInspectRequestSchema = z
     ]))
         .max(100)
         .default([]),
+    lookupOnly: z.boolean().default(false),
     includeOverview: z.boolean().default(true),
     allocationRequests: z.array(mapAllocationRequestSchema).max(100).default([]),
 })
@@ -73,8 +74,28 @@ export const mapRenderRequestSchema = z
     layer: mapLayerSchema.optional(),
     overlays: z.array(mapOverlaySchema).max(12).optional(),
     scale: z.number().int().min(1).max(16).optional(),
+    tile: z
+        .object({
+        x: z.number().int().min(0),
+        y: z.number().int().min(0),
+        width: z.number().int().min(1).max(2_048),
+        height: z.number().int().min(1).max(2_048),
+    })
+        .strict()
+        .optional(),
+    area: z
+        .object({
+        provinceIds: z.array(z.number().int().nonnegative()).max(256).optional(),
+        stateIds: z.array(z.number().int().nonnegative()).max(64).optional(),
+        regionIds: z.array(z.number().int().nonnegative()).max(64).optional(),
+        padding: z.number().int().min(0).max(256).optional(),
+    })
+        .strict()
+        .refine(({ provinceIds, stateIds, regionIds }) => (provinceIds?.length ?? 0) + (stateIds?.length ?? 0) + (regionIds?.length ?? 0) > 0, 'Map area requires at least one province, state, or region ID')
+        .optional(),
 })
-    .strict();
+    .strict()
+    .refine(({ tile, area }) => tile === undefined || area === undefined, 'Choose tile or area, not both');
 export const mapRewriteRequestSchema = z
     .object({
     workspaceId: workspaceIdSchema,

package/dist/hoi4_agent_tools/schemas/technology.js

@@ -132,6 +132,13 @@ export const technologyRenderRequestSchema = z
     categoryId: technologyIdSchema.optional(),
     targetId: technologyIdSchema.optional(),
     maxNodes: z.number().int().min(1).max(2_000).optional(),
+    scenario: z
+        .object({
+        year: z.number().int().min(1).max(9999),
+        researchedTechnologyIds: z.array(technologyIdSchema).max(25_000),
+    })
+        .strict()
+        .optional(),
     includeHtml: z.boolean().optional(),
     refresh: z.boolean().optional(),
 })

package/dist/hoi4_agent_tools/technology/graph.js

@@ -11,6 +11,7 @@ const MAX_EXTERNAL_REFERENCES = 1_000_000;
 const MAX_ISSUES = 100_000;
 const MAX_HELPER_DEPTH = 64;
 const MAX_HELPER_PROJECTIONS = 500_000;
+const MAX_FULL_HELPER_CALLS = 4_096;
 const confidenceRank = {
     confirmed: 0,
     high: 1,
@@ -188,6 +189,20 @@ function activeYearMarkers(values) {
         left.year - right.year ||
         compareCodeUnits(left.name, right.name));
 }
+function activeBackgrounds(values) {
+    const groups = new Map();
+    for (const background of values) {
+        const key = `${background.folderId}\0${background.name}`;
+        const group = groups.get(key) ?? [];
+        group.push(background);
+        groups.set(key, group);
+    }
+    return [...groups.values()]
+        .map((group) => group.sort((left, right) => right.loadOrder - left.loadOrder ||
+        compareCodeUnits(left.sourcePath, right.sourcePath) ||
+        left.location.start.offset - right.location.start.offset)[0])
+        .sort((left, right) => compareCodeUnits(left.folderId, right.folderId) || compareCodeUnits(left.name, right.name));
+}
 function enrichPlacements(placements, edges, gridboxes, technologies, unlocks, itemLayouts, signal) {
     const technologyById = new Map(technologies.map((technology) => [technology.id, technology]));
     const unlockKindsByTechnology = new Map();
@@ -238,11 +253,8 @@ function enrichPlacements(placements, edges, gridboxes, technologies, unlocks, i
     return placements.map((placement) => {
         const roots = rootsFor(placement.technologyId, placement.folderId);
         const branchRootId = roots.length === 1 ? roots[0] : undefined;
-        const expectedGridbox = branchRootId === undefined ? undefined : `${branchRootId}_tree`;
-        const candidates = expectedGridbox === undefined
-            ? []
-            : gridboxes.filter(({ name, folderId }) => name === expectedGridbox &&
-                (folderId === undefined || folderId === placement.folderId));
+        const expectedGridbox = `${branchRootId ?? placement.technologyId}_tree`;
+        const candidates = gridboxes.filter(({ name, folderId }) => name === expectedGridbox && (folderId === undefined || folderId === placement.folderId));
         const gridbox = candidates[0];
         const technology = technologyById.get(placement.technologyId);
         const folderLayouts = layoutsByFolder.get(placement.folderId);
@@ -1155,6 +1167,7 @@ function* technologyGraphAnalysis(snapshot, options) {
     const gridboxes = activeGridboxes(fragments.flatMap(({ gridboxes }) => gridboxes));
     const itemLayouts = activeItemLayouts(fragments.flatMap(({ itemLayouts }) => itemLayouts));
     const yearMarkers = activeYearMarkers(fragments.flatMap(({ yearMarkers }) => yearMarkers));
+    const backgrounds = activeBackgrounds(fragments.flatMap(({ backgrounds }) => backgrounds ?? []));
     const categories = activeCategories(fragments.flatMap(({ categories }) => categories));
     const selectedDoctrines = activeDefinitions(fragments.flatMap(({ doctrineDefinitions }) => doctrineDefinitions));
     const doctrineDefinitions = localiseDoctrines(selectedDoctrines.active, snapshot.index, assets);
@@ -1168,10 +1181,11 @@ function* technologyGraphAnalysis(snapshot, options) {
     const placements = enrichPlacements(basePlacements, edges, gridboxes, technologies, unlocks, itemLayouts, options.signal);
     const unresolved = fragments.flatMap(({ unresolved }) => unresolved);
     const helperCalls = fragments.flatMap(({ helperCalls }) => helperCalls);
-    const walk = options.analysisMode === 'focused'
+    const analysisMode = options.analysisMode ?? (helperCalls.length > MAX_FULL_HELPER_CALLS ? 'focused' : 'full');
+    const walk = analysisMode === 'focused'
         ? undefined
         : yield technologyHelperWalk(helperCalls, snapshot.revision);
-    const externalReferences = expandHelperReferences(fragments.flatMap(({ externalReferences }) => externalReferences), helperCalls, unresolved, options.analysisMode ?? 'full', walk, options.signal);
+    const externalReferences = expandHelperReferences(fragments.flatMap(({ externalReferences }) => externalReferences), helperCalls, unresolved, analysisMode, walk, options.signal);
     const issues = diagnose(technologies, folders, placements, gridboxes, edges, categories, doctrineDefinitions, unlocks, externalReferences, selectedTechnologies.duplicates.map((group) => group.map(({ iconSprite, effectSignatureFields, ...technology }) => ({
         ...technology,
         icon: iconStatus(iconSprite, snapshot.index, assets),
@@ -1197,14 +1211,14 @@ function* technologyGraphAnalysis(snapshot, options) {
     const graph = {
         schemaVersion: TECHNOLOGY_GRAPH_SCHEMA_VERSION,
         parserVersion: TECHNOLOGY_PARSER_VERSION,
-        analysisMode: options.analysisMode ?? 'full',
+        analysisMode,
         workspaceId: snapshot.workspaceId,
         workspaceIdentity: options.workspaceIdentity,
         revision,
         complete: snapshot.complete &&
             unresolved.every(({ kind }) => kind !== 'partial_source') &&
             !unresolved.some(({ blockers }) => blockers.some(({ code }) => code === 'TECH_HELPER_DEPTH_BLOCKED' || code === 'TECH_HELPER_PROJECTION_LIMIT')) &&
-            !(options.analysisMode === 'focused' && helperCalls.length > 0),
+            !(analysisMode === 'focused' && helperCalls.length > 0),
         analysisBoundary: {
             staticAnalysis: true,
             language: 'l_english',
@@ -1215,7 +1229,7 @@ function* technologyGraphAnalysis(snapshot, options) {
                 'meta-generated or variable technology identifiers',
                 'exact AI research choice and runtime research time',
                 'dynamic scripted localisation without supplied runtime values',
-                ...(options.analysisMode === 'focused' && helperCalls.length > 0
+                ...(analysisMode === 'focused' && helperCalls.length > 0
                     ? ['large-workspace scripted-effect helper projections are deferred']
                     : []),
             ],
@@ -1235,6 +1249,7 @@ function* technologyGraphAnalysis(snapshot, options) {
         gridboxes,
         itemLayouts,
         yearMarkers,
+        backgrounds,
         edges,
         categories,
         doctrineDefinitions,