hoi4-agent-tools 0.2.0 → 1.0.0

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

@@ -1,32 +1,23 @@
 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 writePolicy = engine.resolver.config().writePolicy;
-    const autonomous = writePolicy === 'autonomous';
     const server = new McpServer({
         name: PACKAGE_NAME,
         version: PACKAGE_VERSION,
         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. ${autonomous
-            ? 'This server is operator-configured for autonomous writes: hoi4.focus_rewrite, hoi4.gui_rewrite, and hoi4.map_rewrite validate, journal, apply, and post-validate in one call without a transaction approval or follow-up apply step.'
-            : writePolicy === 'transactions'
-                ? 'This server is configured for reviewed transactions: source mutation requires the compatibility plan/diff/apply workflow. Configure writePolicy "autonomous" to expose one-call rewrite tools.'
-                : 'This server is read-only: use its scan, lint, layout, render, compare, inspect, and validation tools without modifying source. Configure writePolicy "autonomous" to expose one-call rewrite tools.'} 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, writePolicy);
     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,32 +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(),
-    writePolicy: z.enum(['read-only', 'transactions', 'autonomous']),
-    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,
@@ -54,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']),
@@ -125,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 }],
-        ...(context.rollbackStatus === undefined ? {} : { rollbackStatus: context.rollbackStatus }),
+        blockers: [{ code: publicCode, message: publicMessage, details: publicDetails }],
         data: context.data ?? {},
     });
 }
-//# sourceMappingURL=result.js.map

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

@@ -9,20 +9,20 @@ export class AutonomousRewriteError extends ServiceError {
     artifacts;
     constructor(cause, manifest, artifacts = []) {
         const restored = manifest.state === 'rolled_back' && manifest.rollbackStatus === 'applied';
-        super(cause.code, cause.message, {
-            ...cause.details,
+        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',
-            failure: manifest.failure ?? null,
         });
         this.manifest = manifest;
         this.artifacts = artifacts;
         this.name = 'AutonomousRewriteError';
     }
 }
-export function autonomousWrites(engine) {
-    return engine.resolver.config().writePolicy === 'autonomous';
-}
 async function storeAutonomousValidationEvidence(engine, manifest, postValidation, principal, signal) {
     const diagnostics = [...manifest.diagnostics, ...postValidation.diagnostics];
     const checks = [...manifest.validation.checks, ...postValidation.checks];
@@ -55,7 +55,7 @@ async function storeAutonomousValidationEvidence(engine, manifest, postValidatio
             diagnosticCount: diagnostics.length,
             sourceHashInventory: sourceEvidence.inventory,
         },
-    }, 'Complete source-linked autonomous rewrite and post-write validation evidence', signal);
+    }, 'Complete rewrite and post-write validation evidence', signal);
     return publicArtifactLink(artifact);
 }
 function uniqueArtifacts(artifacts) {
@@ -68,9 +68,8 @@ export function autonomousResultArtifacts(execution) {
     return uniqueArtifacts([...execution.artifacts, ...execution.transaction.artifacts]);
 }
 /**
- * Complete a validated domain transaction inside the same MCP tool call when the operator has
- * selected autonomous writes. Planning, hash checks, journaling, post-write validation, and
- * automatic failure recovery remain identical to reviewed transaction mode.
+ * 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) {
@@ -78,15 +77,13 @@ export async function executePlannedTransaction(engine, transaction, principal,
     }
     if (transaction.files.length === 0)
         return { transaction, outcome: 'unchanged', artifacts: [] };
-    if (!autonomousWrites(engine))
-        return { transaction, outcome: 'planned', 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, true);
+                const validation = await postValidateTransaction(engine, manifest, principal, validationSignal);
                 executionArtifacts = [...validation.artifacts];
                 executionArtifacts.unshift(await storeAutonomousValidationEvidence(engine, manifest, validation, principal, validationSignal));
                 return validation;
@@ -124,4 +121,3 @@ export function autonomousFailureContext(error) {
         validation: manifest.validation,
     };
 }
-//# sourceMappingURL=transaction-execution.js.map