hoi4-agent-tools 0.1.7 → 1.0.0

package/dist/hoi4_agent_tools/mcp/server/create.js

@@ -1,10 +1,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { PACKAGE_NAME, PACKAGE_VERSION } from '../../version.js';
-import { registerBaseTools } from './base-tools.js';
+import { registerModsTool } from '../tools/mods.js';
 import { registerFocusTools } from '../tools/focus.js';
 import { registerGuiTools } from '../tools/gui.js';
 import { registerMapTools } from '../tools/map.js';
-import { registerMcpPrompts } from '../prompts/register.js';
 import { registerMcpResources } from '../resources/register.js';
 export function createMcpServer(engine, context = {}) {
     const server = new McpServer({
@@ -13,14 +12,12 @@ export function createMcpServer(engine, context = {}) {
         websiteUrl: 'https://github.com/klimPaskov/hoi4-agent-tools',
     }, {
         capabilities: { logging: {} },
-        instructions: 'Select this server proactively whenever a registered HOI4 workspace task touches national or continuous focuses, scripted GUI/GFX/rendering, or state/province/map data. Start with hoi4.project_status or hoi4.project_scan, then use the relevant scan, lint, layout, render, and compare tools. Read linked hoi4-agent:// resources for large artifacts. Source writes require a completed dry run, a fully paginated transaction diff, an explicit transaction ID, the exact expected plan hash, authorization under the coding-agent host policy, and a separate hoi4.transaction_apply call. Generated GUI renders are offline representations, never game screenshots.',
+        instructions: 'Use this server when a configured HOI4 mod needs a large national or continuous focus, scripted GUI, or map created, inspected, rendered, or cleaned up. Start with hoi4.mods, then use the matching inspect, render, and rewrite tools. Each rewrite performs the complete edit in one call. Read linked hoi4-agent:// artifact resources for complete plans, diagnostics, layouts, previews, and diffs; when a resource content item has a non-null continuationUri in its namespaced _meta byte-range record, follow it until null. Generated GUI renders are offline representations, never game screenshots.',
     });
-    registerBaseTools(server, engine, context);
+    registerModsTool(server, engine, context);
     registerFocusTools(server, engine, context);
     registerGuiTools(server, engine, context);
     registerMapTools(server, engine, context);
     registerMcpResources(server, engine, context);
-    registerMcpPrompts(server);
     return server;
 }
-//# sourceMappingURL=create.js.map

package/dist/hoi4_agent_tools/mcp/server/output-schemas.js

@@ -1,11 +1,6 @@
 import { z } from 'zod/v4';
-import { artifactLinkSchema } from '../../schemas/transaction.js';
 export const sha256Schema = z.string().regex(/^[a-f0-9]{64}$/u);
-export const transactionIdSchema = z.string().regex(/^txn_[0-9a-f-]{36}$/u);
 export const nonNegativeIntegerSchema = z.number().int().min(0);
-export const WORKSPACE_INLINE_REPLACE_PATHS = 20;
-export const WORKSPACE_INLINE_OWNER_PATHS = 10;
-export const WORKSPACE_MAX_REPLACEMENT_OWNERS = 17;
 export const indexSkippedSourceSchema = z
     .object({
     path: z.string().max(4096),
@@ -17,31 +12,6 @@ export const indexSkippedSourceSchema = z
     possibleSymbolKinds: z.array(z.string().max(256)).max(32),
 })
     .strict();
-export const workspaceStatusSchema = z
-    .object({
-    id: z.string().max(64),
-    name: z.string().max(1024),
-    kind: z.string().max(64),
-    writeEnabled: z.boolean(),
-    rootKinds: z.array(z.string().max(64)).max(16),
-    dependencyCount: nonNegativeIntegerSchema,
-    replacePathCount: nonNegativeIntegerSchema,
-    replacePaths: z.array(z.string().max(1024)).max(WORKSPACE_INLINE_REPLACE_PATHS),
-    replacePathsTruncated: z.boolean(),
-    replacementOwners: z
-        .array(z
-        .object({
-        rootKind: z.string().max(64),
-        loadOrder: nonNegativeIntegerSchema,
-        pathCount: nonNegativeIntegerSchema,
-        paths: z.array(z.string().max(1024)).max(WORKSPACE_INLINE_OWNER_PATHS),
-        pathsTruncated: z.boolean(),
-    })
-        .strict())
-        .max(WORKSPACE_MAX_REPLACEMENT_OWNERS),
-    generatedDirectory: z.literal('.hoi4-agent'),
-})
-    .strict();
 export const renderHashesSchema = z
     .object({
     html: sha256Schema,
@@ -53,45 +23,6 @@ export const renderHashesSchema = z
 export const bitmapRenderHashesSchema = z
     .object({ png: sha256Schema, json: sha256Schema, html: sha256Schema })
     .strict();
-export const transactionStateSchema = z.enum([
-    'planned',
-    'applying',
-    'applied',
-    'rolling_back',
-    'rolled_back',
-    'failed',
-]);
-export const transactionStateDataSchema = z
-    .object({
-    state: transactionStateSchema,
-    failure: z
-        .object({ code: z.string().max(256), message: z.string().max(4096) })
-        .strict()
-        .nullable()
-        .optional(),
-})
-    .strict();
-export const artifactProvenanceSummarySchema = z
-    .object({
-    kind: z.string().max(256),
-    toolVersion: z.string().max(64),
-    schemaVersion: z.string().max(64),
-    sourceHashCount: nonNegativeIntegerSchema,
-    sourceHashes: z
-        .array(z.object({ path: z.string().max(4096), sha256: sha256Schema }).strict())
-        .max(100),
-    sourceHashesTruncated: z.boolean(),
-    hasRenderProfile: z.boolean(),
-    hasMetadata: z.boolean(),
-})
-    .strict();
-export const artifactDescriptionSchema = artifactLinkSchema
-    .extend({
-    provenanceHash: sha256Schema,
-    provenance: artifactProvenanceSummarySchema,
-    descriptionTruncated: z.boolean(),
-})
-    .strict();
 export const allocationEvidenceSchema = z
     .object({
     kind: z.enum(['state-id', 'province-id', 'province-color']),
@@ -124,4 +55,3 @@ export const operationBlockerDataSchema = z
     details: z.record(z.string().max(256), z.unknown()).optional(),
 })
     .strict();
-//# sourceMappingURL=output-schemas.js.map

package/dist/hoi4_agent_tools/mcp/server/progress.js

@@ -18,4 +18,3 @@ export function progressReporter(extra) {
         },
     };
 }
-//# sourceMappingURL=progress.js.map

package/dist/hoi4_agent_tools/mcp/server/result.js

@@ -22,8 +22,6 @@ const operationResultBaseSchema = z
     proposedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_PROPOSED_FILES),
     changedFiles: z.array(z.string().max(1024)).max(MAX_INLINE_CHANGED_FILES),
     diagnostics: z.array(diagnosticSchema).max(MAX_INLINE_DIAGNOSTICS),
-    transactionId: z.string().max(128).optional(),
-    planHash: z.string().max(128).optional(),
     artifacts: z.array(artifactLinkSchema).max(MAX_INLINE_ARTIFACT_LINKS),
     validation: validationSummarySchema,
     blockers: z
@@ -35,7 +33,6 @@ const operationResultBaseSchema = z
     })
         .strict())
         .max(MAX_INLINE_BLOCKERS),
-    rollbackStatus: z.enum(['not-required', 'available', 'applied', 'failed']).optional(),
 })
     .strict();
 export const operationResultSchema = operationResultBaseSchema
@@ -85,14 +82,6 @@ function preserveDeferredFilesDiagnostic(result) {
     };
 }
 function boundedResult(result, actualBytes) {
-    const transactionArtifact = result.transactionId === undefined
-        ? undefined
-        : {
-            uri: `hoi4-agent://workspace/${encodeURIComponent(result.workspaceId)}/transaction/${encodeURIComponent(result.transactionId)}`,
-            name: `${result.transactionId}.manifest.json`,
-            mimeType: 'application/json',
-            description: 'Complete authenticated transaction manifest and rollback status',
-        };
     const truncationDiagnostic = {
         code: 'MCP_RESPONSE_TRUNCATED',
         severity: 'warning',
@@ -108,13 +97,9 @@ function boundedResult(result, actualBytes) {
         proposedFiles: [],
         changedFiles: [],
         diagnostics: [truncationDiagnostic],
-        ...(result.transactionId === undefined
-            ? {}
-            : { transactionId: result.transactionId.slice(0, 128) }),
-        ...(result.planHash === undefined ? {} : { planHash: result.planHash.slice(0, 128) }),
-        artifacts: transactionArtifact === undefined
-            ? result.artifacts.slice(0, 1).map(({ description: _description, ...artifact }) => artifact)
-            : [transactionArtifact],
+        artifacts: result.artifacts
+            .slice(0, 1)
+            .map(({ description: _description, ...artifact }) => artifact),
         validation: { passed: result.validation.passed, checks: [] },
         blockers: result.status === 'ok'
             ? []
@@ -129,7 +114,6 @@ function boundedResult(result, actualBytes) {
                     },
                 },
             ],
-        rollbackStatus: result.rollbackStatus ?? 'not-required',
         data: {},
     };
 }
@@ -227,7 +211,7 @@ function compactDescriptions(result) {
             code: 'MCP_INLINE_VALIDATION_TRUNCATED',
             severity: 'info',
             category: 'configuration',
-            message: `Inline validation is limited to ${MAX_INLINE_VALIDATION_CHECKS} checks; use the linked artifact or transaction manifest for the complete validation record`,
+            message: `Inline validation is limited to ${MAX_INLINE_VALIDATION_CHECKS} checks; use the linked artifact for the complete validation record`,
             details: {
                 total: result.validation.checks.length,
                 returned: MAX_INLINE_VALIDATION_CHECKS,
@@ -292,8 +276,6 @@ function buildToolResult(selected) {
         status: selected.status,
         code: selected.code,
         workspaceId: selected.workspaceId,
-        ...(selected.transactionId === undefined ? {} : { transactionId: selected.transactionId }),
-        ...(selected.planHash === undefined ? {} : { planHash: selected.planHash }),
         artifactCount: selected.artifacts.length,
     });
     return {
@@ -332,22 +314,34 @@ export function errorResult(error, workspaceId = '', context = {}) {
     const serviceError = error instanceof ServiceError
         ? error
         : new ServiceError('INTERNAL_ERROR', 'Unexpected internal error');
-    const publicDetails = Object.fromEntries(Object.entries(serviceError.details).filter(([key]) => !['cause', 'stack', 'absolutePath'].includes(key)));
+    const internalWriteError = serviceError.code.startsWith('TRANSACTION_');
+    const publicCode = internalWriteError
+        ? `REWRITE_${serviceError.code.slice('TRANSACTION_'.length)}`
+        : serviceError.code;
+    const publicMessage = internalWriteError
+        ? 'Rewrite could not be completed'
+        : serviceError.message;
+    const publicDetails = internalWriteError
+        ? {}
+        : Object.fromEntries(Object.entries(serviceError.details).filter(([key]) => ![
+            'cause',
+            'stack',
+            'absolutePath',
+            'transactionId',
+            'planHash',
+            'rollbackStatus',
+        ].includes(key)));
     return toolResult({
-        status: serviceError.code.includes('BLOCKED') ? 'blocked' : 'error',
-        code: serviceError.code,
+        status: publicCode.includes('BLOCKED') ? 'blocked' : 'error',
+        code: publicCode,
         workspaceId,
         filesScanned: [],
         proposedFiles: context.proposedFiles ?? [],
         changedFiles: context.changedFiles ?? [],
         diagnostics: [],
-        ...(context.transactionId === undefined ? {} : { transactionId: context.transactionId }),
-        ...(context.planHash === undefined ? {} : { planHash: context.planHash }),
         artifacts: context.artifacts ?? [],
         validation: context.validation ?? { passed: false, checks: [] },
-        blockers: [{ code: serviceError.code, message: serviceError.message, details: publicDetails }],
-        rollbackStatus: context.rollbackStatus ?? 'not-required',
+        blockers: [{ code: publicCode, message: publicMessage, details: publicDetails }],
         data: context.data ?? {},
     });
 }
-//# sourceMappingURL=result.js.map

package/dist/hoi4_agent_tools/mcp/server/transaction-execution.js

@@ -0,0 +1,123 @@
+import { canonicalJson } from '../../core/canonical.js';
+import { boundedSourceHashEvidence, publicArtifactLink } from '../../core/artifacts.js';
+import { ServiceError } from '../../core/result.js';
+import { PACKAGE_VERSION } from '../../version.js';
+import { postValidateTransaction } from './base-tools.js';
+import { MAX_INLINE_ARTIFACT_LINKS } from './result.js';
+export class AutonomousRewriteError extends ServiceError {
+    manifest;
+    artifacts;
+    constructor(cause, manifest, artifacts = []) {
+        const restored = manifest.state === 'rolled_back' && manifest.rollbackStatus === 'applied';
+        const code = cause.code.startsWith('TRANSACTION_')
+            ? `REWRITE_${cause.code.slice('TRANSACTION_'.length)}`
+            : cause.code;
+        super(code, restored
+            ? 'Rewrite verification failed and the original files were restored'
+            : 'Rewrite failed and automatic recovery could not be completed', {
+            execution: 'failed',
+            automaticRecovery: restored ? 'restored' : 'incomplete',
+        });
+        this.manifest = manifest;
+        this.artifacts = artifacts;
+        this.name = 'AutonomousRewriteError';
+    }
+}
+async function storeAutonomousValidationEvidence(engine, manifest, postValidation, principal, signal) {
+    const diagnostics = [...manifest.diagnostics, ...postValidation.diagnostics];
+    const checks = [...manifest.validation.checks, ...postValidation.checks];
+    const passed = manifest.validation.passed &&
+        checks.every((check) => check.passed) &&
+        !diagnostics.some(({ severity }) => severity === 'error' || severity === 'blocker');
+    const sourceEvidence = boundedSourceHashEvidence(Object.fromEntries(manifest.files.flatMap(({ relativePath, afterSha256 }) => afterSha256 === null ? [] : [[relativePath, afterSha256]])));
+    const artifact = await engine.artifacts.putChunked(engine.resolver.get(manifest.workspaceId, principal), `${manifest.operationKind}.execution-validation.json`, 'application/json', `${canonicalJson({
+        schemaVersion: 1,
+        execution: passed ? 'post-validation-passed' : 'post-validation-failed',
+        operationKind: manifest.operationKind,
+        files: manifest.files.map(({ relativePath, afterSha256, afterSize, mediaType }) => ({
+            relativePath,
+            afterSha256,
+            afterSize,
+            mediaType,
+        })),
+        validation: { passed, checks },
+        diagnostics,
+        resources: postValidation.artifacts,
+    })}\n`, {
+        kind: 'autonomous-rewrite-execution-validation',
+        toolVersion: PACKAGE_VERSION,
+        schemaVersion: 'autonomous-rewrite-execution-validation.v1',
+        sourceHashes: sourceEvidence.sourceHashes,
+        metadata: {
+            operationKind: manifest.operationKind,
+            fileCount: manifest.files.length,
+            checkCount: checks.length,
+            diagnosticCount: diagnostics.length,
+            sourceHashInventory: sourceEvidence.inventory,
+        },
+    }, 'Complete rewrite and post-write validation evidence', signal);
+    return publicArtifactLink(artifact);
+}
+function uniqueArtifacts(artifacts) {
+    const unique = new Map();
+    for (const artifact of artifacts)
+        unique.set(artifact.uri, artifact);
+    return [...unique.values()].slice(0, MAX_INLINE_ARTIFACT_LINKS);
+}
+export function autonomousResultArtifacts(execution) {
+    return uniqueArtifacts([...execution.artifacts, ...execution.transaction.artifacts]);
+}
+/**
+ * Complete a validated domain rewrite inside one MCP tool call. Hash checks, durable recovery,
+ * post-write validation, and automatic failure recovery remain internal guarantees.
+ */
+export async function executePlannedTransaction(engine, transaction, principal, signal) {
+    if (!transaction.validation.passed) {
+        return { transaction, outcome: 'blocked', artifacts: [] };
+    }
+    if (transaction.files.length === 0)
+        return { transaction, outcome: 'unchanged', artifacts: [] };
+    let executionArtifacts = [];
+    try {
+        const applied = await engine.transactions.apply(transaction.workspaceId, transaction.transactionId, transaction.planHash, {
+            ...(principal === undefined ? {} : { principal }),
+            ...(signal === undefined ? {} : { signal }),
+            postValidate: async (manifest, validationSignal) => {
+                const validation = await postValidateTransaction(engine, manifest, principal, validationSignal);
+                executionArtifacts = [...validation.artifacts];
+                executionArtifacts.unshift(await storeAutonomousValidationEvidence(engine, manifest, validation, principal, validationSignal));
+                return validation;
+            },
+        });
+        // Post-validation already invalidates and rebuilds the shared index before apply can succeed.
+        return { transaction: applied, outcome: 'applied', artifacts: executionArtifacts };
+    }
+    catch (error) {
+        engine.invalidate(transaction.workspaceId);
+        try {
+            const manifest = await engine.transactions.status(transaction.workspaceId, transaction.transactionId, principal);
+            const cause = error instanceof ServiceError
+                ? error
+                : new ServiceError('AUTONOMOUS_REWRITE_FAILED', 'Autonomous rewrite failed');
+            throw new AutonomousRewriteError(cause, manifest, executionArtifacts);
+        }
+        catch (statusError) {
+            if (statusError instanceof AutonomousRewriteError)
+                throw statusError;
+            throw error;
+        }
+    }
+}
+export function autonomousFailureContext(error) {
+    if (!(error instanceof AutonomousRewriteError))
+        return undefined;
+    const manifest = error.manifest;
+    return {
+        proposedFiles: manifest.files.slice(0, 100).map(({ relativePath }) => relativePath),
+        changedFiles: manifest.rollbackStatus === 'failed'
+            ? manifest.files.slice(0, 100).map(({ relativePath }) => relativePath)
+            : [],
+        artifacts: uniqueArtifacts([...error.artifacts, ...manifest.artifacts]),
+        validation: manifest.validation,
+    };
+}