hoi4-agent-tools 3.2.0 → 3.4.0

package/dist/hoi4_agent_tools/schemas/scenarios.js

@@ -0,0 +1,264 @@
+import { z } from 'zod/v4';
+import { declaredConditionScenarioSchema } from './analysis.js';
+import { workspaceIdSchema, workspaceRelativePathSchema } from './common.js';
+const identifier = z.string().min(1).max(512);
+const manifestToken = z.string().regex(/^[A-Za-z0-9_.:-]{1,512}$/u);
+const sourceSelector = z
+    .object({
+    kind: z.enum(['scripted_effect', 'event_option', 'decision', 'focus_reward']),
+    id: identifier,
+    option: identifier.optional(),
+})
+    .strict();
+export const sharedScenarioSchema = declaredConditionScenarioSchema.safeExtend({
+    schemaVersion: z.literal('1.0'),
+    globalFlags: z.array(identifier).max(10_000).optional(),
+    scopeCatalogs: z
+        .record(identifier, z
+        .object({
+        complete: z.boolean(),
+        members: z.array(identifier).max(2_048),
+    })
+        .strict())
+        .optional(),
+});
+const assertionPath = z
+    .object({
+    scope: identifier.default('ROOT'),
+    key: identifier,
+})
+    .strict();
+const scalar = z.union([z.string().max(4_096), z.number(), z.boolean(), z.null()]);
+export const mechanicAssertionSchema = z.discriminatedUnion('kind', [
+    z
+        .object({ id: identifier, kind: z.literal('equals'), path: assertionPath, expected: scalar })
+        .strict(),
+    z
+        .object({
+        id: identifier,
+        kind: z.literal('conservation'),
+        paths: z.array(assertionPath).min(2).max(64),
+        tolerance: z.number().nonnegative().default(0),
+    })
+        .strict(),
+    z
+        .object({
+        id: identifier,
+        kind: z.literal('array_alignment'),
+        paths: z.array(assertionPath).min(2).max(32),
+    })
+        .strict(),
+    z
+        .object({
+        id: identifier,
+        kind: z.literal('affordability'),
+        balance: assertionPath,
+        cost: z.number().nonnegative(),
+    })
+        .strict(),
+    z
+        .object({
+        id: identifier,
+        kind: z.literal('single_payment'),
+        balance: assertionPath,
+        cost: z.number().nonnegative(),
+    })
+        .strict(),
+    z
+        .object({
+        id: identifier,
+        kind: z.literal('repeated_setup'),
+        firstStep: z.number().int().nonnegative(),
+        secondStep: z.number().int().nonnegative(),
+    })
+        .strict(),
+    z
+        .object({
+        id: identifier,
+        kind: z.literal('exclusive_flags'),
+        scope: identifier.default('ROOT'),
+        flags: z.array(identifier).min(2).max(64),
+    })
+        .strict(),
+    z
+        .object({
+        id: identifier,
+        kind: z.literal('cleanup'),
+        scope: identifier.default('ROOT'),
+        flags: z.array(identifier).max(64).default([]),
+        targets: z.array(identifier).max(64).default([]),
+    })
+        .strict(),
+    z
+        .object({ id: identifier, kind: z.literal('end_state'), path: assertionPath, expected: scalar })
+        .strict(),
+]);
+export const mechanicCaseSchema = z
+    .object({
+    id: identifier,
+    scenario: sharedScenarioSchema,
+    steps: z
+        .array(z.discriminatedUnion('kind', [
+        z
+            .object({
+            kind: z.literal('effect'),
+            source: sourceSelector,
+            repeat: z.number().int().min(1).max(8).default(1),
+        })
+            .strict(),
+        z
+            .object({ kind: z.literal('advance_days'), days: z.number().int().min(0).max(36_500) })
+            .strict(),
+    ]))
+        .min(1)
+        .max(128),
+    assertions: z.array(mechanicAssertionSchema).min(1).max(256),
+})
+    .strict();
+export const mechanicTestRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    test: mechanicCaseSchema,
+    expectedRevision: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    refresh: z.boolean().default(false),
+})
+    .strict();
+const manifestItem = z.object({ kind: manifestToken, id: manifestToken }).strict();
+export const packageManifestSchema = z
+    .object({
+    schemaVersion: z.literal('1.0'),
+    id: manifestToken,
+    definitions: z.array(manifestItem).max(2_048).default([]),
+    calls: z
+        .array(z.object({ from: manifestItem, to: manifestItem }).strict())
+        .max(2_048)
+        .default([]),
+    registrations: z
+        .array(z.object({ path: workspaceRelativePathSchema, token: manifestToken }).strict())
+        .max(2_048)
+        .default([]),
+    localisation: z.array(manifestToken).max(2_048).default([]),
+    assets: z.array(workspaceRelativePathSchema).max(2_048).default([]),
+    requiredCases: z
+        .array(z.object({ suite: workspaceRelativePathSchema, caseId: manifestToken }).strict())
+        .max(512)
+        .default([]),
+})
+    .strict();
+export const packageCheckRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    manifest: packageManifestSchema,
+    expectedRevision: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    refresh: z.boolean().default(false),
+})
+    .strict();
+const readOnlySuiteTool = z.enum([
+    'hoi4.impact_inspect',
+    'hoi4.decision_inspect',
+    'hoi4.event_inspect',
+    'hoi4.event_render',
+    'hoi4.tech_inspect',
+    'hoi4.tech_render',
+    'hoi4.probability_inspect',
+    'hoi4.probability_evaluate',
+    'hoi4.probability_render',
+    'hoi4.focus_inspect',
+    'hoi4.focus_render',
+    'hoi4.gui_inspect',
+    'hoi4.gui_render',
+    'hoi4.map_inspect',
+    'hoi4.map_render',
+]);
+const suiteCaseMetadata = {
+    sourceSelectors: z.array(manifestItem).max(64).default([]),
+    assertions: z
+        .array(z
+        .object({
+        id: identifier,
+        path: z.array(identifier).min(1).max(16),
+        expected: scalar,
+    })
+        .strict())
+        .max(64)
+        .default([]),
+    views: z
+        .array(z.enum(['summary', 'artifacts', 'diagnostics']))
+        .max(3)
+        .default(['summary']),
+};
+export const scenarioSuiteSchema = z
+    .object({
+    schemaVersion: z.literal('1.0'),
+    id: identifier,
+    cases: z
+        .array(z.discriminatedUnion('domain', [
+        z
+            .object({
+            domain: z.literal('mechanic'),
+            id: identifier,
+            test: mechanicCaseSchema,
+            ...suiteCaseMetadata,
+        })
+            .strict(),
+        z
+            .object({
+            domain: z.literal('package'),
+            id: identifier,
+            manifest: packageManifestSchema,
+            ...suiteCaseMetadata,
+        })
+            .strict(),
+        z
+            .object({
+            domain: z.literal('tool'),
+            id: identifier,
+            tool: readOnlySuiteTool,
+            arguments: z.record(z.string().max(256), z.json()),
+            ...suiteCaseMetadata,
+        })
+            .strict(),
+    ]))
+        .min(1)
+        .max(10_000),
+})
+    .strict()
+    .superRefine((suite, context) => {
+    const ids = new Set();
+    for (const [index, item] of suite.cases.entries()) {
+        if (ids.has(item.id))
+            context.addIssue({
+                code: 'custom',
+                path: ['cases', index, 'id'],
+                message: 'Suite case ids must be unique',
+            });
+        ids.add(item.id);
+    }
+});
+export const scenarioTestRequestSchema = z
+    .object({
+    workspaceId: workspaceIdSchema,
+    suite: scenarioSuiteSchema.optional(),
+    suitePath: workspaceRelativePathSchema.optional(),
+    continuation: z.string().max(4_096).optional(),
+    maxCases: z.number().int().min(1).max(256).default(32),
+    expectedRevision: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .optional(),
+    refresh: z.boolean().default(false),
+})
+    .strict()
+    .superRefine((input, context) => {
+    if ((input.suite === undefined) === (input.suitePath === undefined))
+        context.addIssue({
+            code: 'custom',
+            message: 'Specify exactly one inline suite or suitePath',
+        });
+});

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,