il2cpp-dump-analyzer-mcp
Version:
Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games
261 lines • 8.84 kB
JavaScript
;
/**
* Template engine integration for IL2CPP code generation
* Supports multiple template engines with a unified interface
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.TemplateManager = exports.TemplateEngineFactory = exports.SimpleReplaceEngine = void 0;
const types_1 = require("./types");
/**
* Simple string replacement template engine
*/
class SimpleReplaceEngine {
constructor() {
this.type = types_1.TemplateEngine.SIMPLE_REPLACE;
}
/**
* Render template using simple string replacement
* Variables are replaced using {{variableName}} syntax
*/
async render(template, context) {
const startTime = Date.now();
const errors = [];
try {
let content = template;
// Replace variables
for (const [key, value] of Object.entries(context.variables)) {
const placeholder = `{{${key}}}`;
const stringValue = this.convertToString(value);
content = content.replace(new RegExp(placeholder, 'g'), stringValue);
}
// Check for unreplaced placeholders
const unreplacedMatches = content.match(/{{[^}]+}}/g);
if (unreplacedMatches) {
for (const match of unreplacedMatches) {
errors.push({
type: types_1.GenerationErrorType.TEMPLATE_ERROR,
message: `Unreplaced template variable: ${match}`,
code: 'UNREPLACED_VARIABLE',
context: 'Template rendering'
});
}
}
return {
success: errors.length === 0,
content: errors.length === 0 ? content : undefined,
errors,
processingTime: Date.now() - startTime
};
}
catch (error) {
errors.push({
type: types_1.GenerationErrorType.TEMPLATE_ERROR,
message: error instanceof Error ? error.message : 'Template rendering failed',
code: 'RENDER_ERROR',
context: 'SimpleReplaceEngine.render'
});
return {
success: false,
errors,
processingTime: Date.now() - startTime
};
}
}
/**
* Validate template syntax
*/
async validate(template) {
try {
// Check for balanced braces
const openBraces = (template.match(/{{/g) || []).length;
const closeBraces = (template.match(/}}/g) || []).length;
return openBraces === closeBraces;
}
catch {
return false;
}
}
/**
* Compile template for reuse
*/
async compile(template) {
const requiredVariables = this.extractVariables(template);
return {
render: async (context) => this.render(template, context),
getRequiredVariables: () => requiredVariables
};
}
/**
* Extract variable names from template
*/
extractVariables(template) {
const matches = template.match(/{{([^}]+)}}/g) || [];
return matches.map(match => match.replace(/[{}]/g, '').trim());
}
/**
* Convert value to string representation
*/
convertToString(value) {
if (value === null || value === undefined) {
return '';
}
if (typeof value === 'string') {
return value;
}
if (typeof value === 'boolean') {
return value ? 'true' : 'false';
}
if (Array.isArray(value)) {
return value.join(', ');
}
if (typeof value === 'object') {
return JSON.stringify(value);
}
return String(value);
}
}
exports.SimpleReplaceEngine = SimpleReplaceEngine;
/**
* Template engine factory
*/
class TemplateEngineFactory {
/**
* Get template engine instance
*/
static getEngine(type) {
if (!this.engines.has(type)) {
this.engines.set(type, this.createEngine(type));
}
return this.engines.get(type);
}
/**
* Create template engine instance
*/
static createEngine(type) {
switch (type) {
case types_1.TemplateEngine.SIMPLE_REPLACE:
return new SimpleReplaceEngine();
case types_1.TemplateEngine.HANDLEBARS:
// TODO: Implement Handlebars engine when needed
throw new Error('Handlebars engine not yet implemented');
case types_1.TemplateEngine.MUSTACHE:
// TODO: Implement Mustache engine when needed
throw new Error('Mustache engine not yet implemented');
default:
throw new Error(`Unsupported template engine: ${type}`);
}
}
}
exports.TemplateEngineFactory = TemplateEngineFactory;
TemplateEngineFactory.engines = new Map();
/**
* Template manager for handling template configurations
*/
class TemplateManager {
constructor() {
this.templates = new Map();
this.compiledTemplates = new Map();
}
/**
* Register a template configuration
*/
registerTemplate(config) {
this.templates.set(config.name, config);
}
/**
* Get template configuration
*/
getTemplate(name) {
return this.templates.get(name);
}
/**
* Render template with context
*/
async renderTemplate(templateName, context) {
const config = this.templates.get(templateName);
if (!config) {
return {
success: false,
errors: [{
type: types_1.GenerationErrorType.TEMPLATE_ERROR,
message: `Template not found: ${templateName}`,
code: 'TEMPLATE_NOT_FOUND',
context: 'TemplateManager.renderTemplate'
}],
processingTime: 0
};
}
// Validate required variables
const validationErrors = this.validateContext(config, context);
if (validationErrors.length > 0) {
return {
success: false,
errors: validationErrors,
processingTime: 0
};
}
const engine = TemplateEngineFactory.getEngine(config.engine);
return engine.render(config.template, context);
}
/**
* Compile and cache template
*/
async compileTemplate(templateName) {
if (this.compiledTemplates.has(templateName)) {
return this.compiledTemplates.get(templateName);
}
const config = this.templates.get(templateName);
if (!config) {
return null;
}
const engine = TemplateEngineFactory.getEngine(config.engine);
const compiled = await engine.compile(config.template);
this.compiledTemplates.set(templateName, compiled);
return compiled;
}
/**
* Validate template context against configuration
*/
validateContext(config, context) {
const errors = [];
for (const [varName, varConfig] of Object.entries(config.variables)) {
if (varConfig.required && !(varName in context.variables)) {
errors.push({
type: types_1.GenerationErrorType.VALIDATION_ERROR,
message: `Required template variable missing: ${varName}`,
code: 'MISSING_REQUIRED_VARIABLE',
context: `Template: ${config.name}`
});
}
if (varName in context.variables) {
const value = context.variables[varName];
const expectedType = varConfig.type;
const actualType = Array.isArray(value) ? 'array' : typeof value;
if (actualType !== expectedType) {
errors.push({
type: types_1.GenerationErrorType.VALIDATION_ERROR,
message: `Template variable type mismatch: ${varName} expected ${expectedType}, got ${actualType}`,
code: 'VARIABLE_TYPE_MISMATCH',
context: `Template: ${config.name}`
});
}
}
}
return errors;
}
/**
* Get all registered template names
*/
getTemplateNames() {
return Array.from(this.templates.keys());
}
/**
* Clear all templates and compiled cache
*/
clear() {
this.templates.clear();
this.compiledTemplates.clear();
}
}
exports.TemplateManager = TemplateManager;
//# sourceMappingURL=template-engine.js.map