faultmesh 1.0.0 → 1.1.0

package/dist/engine/ControlApi.d.ts

@@ -3,6 +3,9 @@ import { TelemetryHub } from './TelemetryHub.js';
 import { ResilienceScorer } from '../scorer/ResilienceScorer.js';
 import { SecurityAuditor } from '../scorer/SecurityAuditor.js';
 import { TrafficStormAuditor } from '../scorer/TrafficStormAuditor.js';
+import { FaultMeshProxy } from './FaultMeshProxy.js';
+import { EccAgentBridge } from '../redteam/EccAgentBridge.js';
+import { RedTeamEngine } from '../redteam/RedTeamEngine.js';
 export declare class ControlApi {
     private server;
     private port;
@@ -12,12 +15,21 @@ export declare class ControlApi {
     private securityAuditor;
     private trafficStormAuditor;
     private dashboardDir;
+    private proxy?;
+    private eccBridge;
+    private redTeamEngine;
     private isRunning;
-    constructor(port: number, pipeline: ToxicPipeline, telemetryHub: TelemetryHub, scorer: ResilienceScorer, securityAuditor?: SecurityAuditor, trafficStormAuditor?: TrafficStormAuditor, dashboardDir?: string);
+    constructor(port: number, pipeline: ToxicPipeline, telemetryHub: TelemetryHub, scorer: ResilienceScorer, securityAuditor?: SecurityAuditor, trafficStormAuditor?: TrafficStormAuditor, dashboardDir?: string, proxy?: FaultMeshProxy, redTeamEngine?: RedTeamEngine, eccBridge?: EccAgentBridge);
     private handleRequest;
+    setProxy(proxy: FaultMeshProxy): void;
+    getRedTeamEngine(): RedTeamEngine;
+    getEccBridge(): EccAgentBridge;
     private serveStatic;
     private readBody;
     private json;
+    private sampleProcess?;
+    private restartSampleBackend;
+    private killPort;
     start(): Promise<void>;
     stop(): Promise<void>;
     getPort(): number;

package/dist/engine/ControlApi.js

@@ -2,8 +2,12 @@ import http from 'node:http';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { execSync, spawn } from 'node:child_process';
 import { SecurityAuditor } from '../scorer/SecurityAuditor.js';
 import { TrafficStormAuditor } from '../scorer/TrafficStormAuditor.js';
+import { AutoHealer } from '../healer/AutoHealer.js';
+import { EccAgentBridge } from '../redteam/EccAgentBridge.js';
+import { RedTeamEngine } from '../redteam/RedTeamEngine.js';
 export class ControlApi {
     server;
     port = 0;
@@ -13,14 +17,20 @@ export class ControlApi {
     securityAuditor;
     trafficStormAuditor;
     dashboardDir;
+    proxy;
+    eccBridge;
+    redTeamEngine;
     isRunning = false;
-    constructor(port, pipeline, telemetryHub, scorer, securityAuditor, trafficStormAuditor, dashboardDir) {
+    constructor(port, pipeline, telemetryHub, scorer, securityAuditor, trafficStormAuditor, dashboardDir, proxy, redTeamEngine, eccBridge) {
         this.port = port;
         this.pipeline = pipeline;
         this.telemetryHub = telemetryHub;
         this.scorer = scorer;
         this.securityAuditor = securityAuditor || new SecurityAuditor('http://127.0.0.1:3001');
         this.trafficStormAuditor = trafficStormAuditor || new TrafficStormAuditor('http://127.0.0.1:3001');
+        this.proxy = proxy;
+        this.eccBridge = eccBridge || new EccAgentBridge();
+        this.redTeamEngine = redTeamEngine || new RedTeamEngine(this.pipeline, this.telemetryHub, this.eccBridge);
         const currentDir = path.dirname(fileURLToPath(import.meta.url));
         let resolvedDir = dashboardDir || path.resolve(currentDir, '../dashboard');
         if (!fs.existsSync(resolvedDir)) {
@@ -33,6 +43,11 @@ export class ControlApi {
         this.server = http.createServer((req, res) => this.handleRequest(req, res));
     }
     async handleRequest(req, res) {
+        const rawUrl = req.url || '/';
+        if (rawUrl.includes('/..') || rawUrl.includes('..\\') || rawUrl.toLowerCase().includes('%2e%2e') || rawUrl.includes('\0')) {
+            this.json(res, 403, { error: 'Access Denied: Path Traversal Prohibited' });
+            return;
+        }
         const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
         const pathname = url.pathname;
         // Enable CORS for local dashboards or external runners
@@ -189,6 +204,186 @@ export class ControlApi {
             }
             return;
         }
+        // 8.5 Dynamic Target API Configuration
+        if (pathname === '/_faultmesh/config/target') {
+            if (req.method === 'GET') {
+                const currentTarget = this.proxy ? this.proxy.getTargetUrl() : 'http://127.0.0.1:4000';
+                this.json(res, 200, { targetUrl: currentTarget });
+                return;
+            }
+            if (req.method === 'POST') {
+                const raw = await this.readBody(req);
+                try {
+                    const body = JSON.parse(raw);
+                    if (!body.targetUrl || typeof body.targetUrl !== 'string') {
+                        this.json(res, 400, { error: 'targetUrl is required and must be a string' });
+                        return;
+                    }
+                    // Validate URL format
+                    new URL(body.targetUrl);
+                    if (this.proxy) {
+                        this.proxy.setTargetUrl(body.targetUrl);
+                    }
+                    if (this.securityAuditor) {
+                        this.securityAuditor.setTargetUrl(body.targetUrl);
+                    }
+                    if (this.trafficStormAuditor) {
+                        this.trafficStormAuditor.setTargetUrl(body.targetUrl);
+                    }
+                    this.json(res, 200, { success: true, targetUrl: body.targetUrl });
+                }
+                catch (err) {
+                    this.json(res, 400, { error: 'Invalid target URL format', details: err.message });
+                }
+                return;
+            }
+        }
+        // 8.6 Auto-Healer Endpoints
+        if (pathname === '/_faultmesh/healer/scan' && req.method === 'POST') {
+            try {
+                const raw = await this.readBody(req);
+                const body = raw ? JSON.parse(raw) : {};
+                const projectDir = body.projectDir || '.';
+                const failedChecks = body.failedChecks || [];
+                const aiConfig = body.aiConfig;
+                const engineMode = body.engineMode;
+                const scanResult = await AutoHealer.scan({ projectDir, failedChecks, aiConfig, engineMode });
+                this.json(res, 200, scanResult);
+            }
+            catch (err) {
+                this.json(res, 500, { error: 'AutoHealer scan error', details: err.message });
+            }
+            return;
+        }
+        if (pathname === '/_faultmesh/healer/apply' && req.method === 'POST') {
+            try {
+                const raw = await this.readBody(req);
+                const body = raw ? JSON.parse(raw) : {};
+                const projectDir = body.projectDir || '.';
+                const patchIds = body.patchIds;
+                const failedChecks = body.failedChecks;
+                const createBackup = body.createBackup !== false;
+                const aiConfig = body.aiConfig;
+                const engineMode = body.engineMode;
+                const applyResult = await AutoHealer.apply({ projectDir, patchIds, failedChecks, createBackup, aiConfig, engineMode });
+                // If healing the sample backend, automatically restart it so memory updates immediately and switch proxy target
+                if (applyResult.success && projectDir.includes('vulnerable-backend')) {
+                    await this.restartSampleBackend();
+                    if (this.proxy) {
+                        this.proxy.setTargetUrl('http://127.0.0.1:5050');
+                    }
+                    if (this.securityAuditor) {
+                        this.securityAuditor.setTargetUrl('http://127.0.0.1:5050');
+                    }
+                    if (this.trafficStormAuditor) {
+                        this.trafficStormAuditor.setTargetUrl('http://127.0.0.1:5050');
+                    }
+                }
+                this.json(res, 200, applyResult);
+            }
+            catch (err) {
+                this.json(res, 500, { error: 'AutoHealer apply error', details: err.message });
+            }
+            return;
+        }
+        if (pathname === '/_faultmesh/healer/rollback' && req.method === 'POST') {
+            try {
+                const raw = await this.readBody(req);
+                const body = raw ? JSON.parse(raw) : {};
+                if (!body.backupDir) {
+                    this.json(res, 400, { error: 'backupDir is required for rollback' });
+                    return;
+                }
+                const projectDir = body.projectDir || '.';
+                const rollbackResult = await AutoHealer.rollback({ projectDir, backupDir: body.backupDir });
+                if (rollbackResult.success && projectDir.includes('vulnerable-backend')) {
+                    await this.restartSampleBackend();
+                }
+                this.json(res, 200, rollbackResult);
+            }
+            catch (err) {
+                this.json(res, 500, { error: 'AutoHealer rollback error', details: err.message });
+            }
+            return;
+        }
+        if (pathname === '/_faultmesh/sample/restart' && req.method === 'POST') {
+            try {
+                await this.restartSampleBackend();
+                this.json(res, 200, { success: true, message: 'Sample backend restarted on port 5050' });
+            }
+            catch (err) {
+                this.json(res, 500, { error: 'Failed to restart sample backend', details: err.message });
+            }
+            return;
+        }
+        if (pathname === '/_faultmesh/sample/reset' && req.method === 'POST') {
+            try {
+                const baselinePath = path.resolve(process.cwd(), 'examples/vulnerable-backend/baseline-vulnerable.js');
+                const targetPath = path.resolve(process.cwd(), 'examples/vulnerable-backend/server.js');
+                if (fs.existsSync(baselinePath)) {
+                    fs.copyFileSync(baselinePath, targetPath);
+                }
+                await this.restartSampleBackend();
+                if (this.proxy) {
+                    this.proxy.setTargetUrl('http://127.0.0.1:5050');
+                }
+                this.json(res, 200, { success: true, message: 'Sample backend restored to baseline vulnerable state on port 5050' });
+            }
+            catch (err) {
+                this.json(res, 500, { error: 'Failed to reset sample backend', details: err.message });
+            }
+            return;
+        }
+        // 8.8 Autonomous Red Chaos Team Engine
+        if (pathname === '/_faultmesh/redteam/personas' && req.method === 'GET') {
+            try {
+                const personas = await this.eccBridge.getPersonas();
+                this.json(res, 200, { success: true, personas });
+            }
+            catch (err) {
+                this.json(res, 500, { error: 'Failed to load agent personas', details: err.message });
+            }
+            return;
+        }
+        if (pathname === '/_faultmesh/redteam/start' && req.method === 'POST') {
+            try {
+                const raw = await this.readBody(req);
+                const options = raw ? JSON.parse(raw) : {};
+                if (options.targetUrl && options.targetUrl.includes(':5050')) {
+                    if (this.proxy) {
+                        this.proxy.setTargetUrl('http://127.0.0.1:5050');
+                    }
+                }
+                if (!options.targetUrl || options.targetUrl.includes(':4000') || options.targetUrl.includes(':5050')) {
+                    options.targetUrl = 'http://127.0.0.1:3001';
+                }
+                // Start campaign asynchronously in background
+                const campaignPromise = this.redTeamEngine.startCampaign(options);
+                campaignPromise.catch(err => {
+                    console.error('Red Team background campaign error:', err.message);
+                });
+                const initialStatus = this.redTeamEngine.getStatus();
+                this.json(res, 202, { success: true, message: 'Red Team campaign initiated', status: initialStatus });
+            }
+            catch (err) {
+                this.json(res, 400, { error: 'Failed to start Red Team campaign', details: err.message });
+            }
+            return;
+        }
+        if (pathname === '/_faultmesh/redteam/abort' && req.method === 'POST') {
+            const result = this.redTeamEngine.abortCampaign();
+            this.json(res, 200, result);
+            return;
+        }
+        if (pathname === '/_faultmesh/redteam/status' && req.method === 'GET') {
+            this.json(res, 200, this.redTeamEngine.getStatus());
+            return;
+        }
+        if (pathname === '/_faultmesh/redteam/report' && req.method === 'GET') {
+            const report = this.redTeamEngine.getReport();
+            this.json(res, 200, report || { message: 'No campaign report recorded yet' });
+            return;
+        }
         // 9. Static Dashboard Serving
         if (req.method === 'GET') {
             this.serveStatic(pathname, res);
@@ -196,14 +391,40 @@ export class ControlApi {
         }
         this.json(res, 404, { error: 'Route not found' });
     }
+    setProxy(proxy) {
+        this.proxy = proxy;
+    }
+    getRedTeamEngine() {
+        return this.redTeamEngine;
+    }
+    getEccBridge() {
+        return this.eccBridge;
+    }
     serveStatic(pathname, res) {
-        const safePath = pathname === '/' ? 'index.html' : pathname.replace(/^\//, '');
-        const filePath = path.join(this.dashboardDir, safePath);
-        // Prevent directory traversal
-        if (!filePath.startsWith(this.dashboardDir)) {
-            this.json(res, 403, { error: 'Forbidden' });
+        const normalizedDashboardDir = path.resolve(this.dashboardDir);
+        let decodedPath = '';
+        try {
+            decodedPath = decodeURIComponent(pathname);
+        }
+        catch {
+            this.json(res, 400, { error: 'Invalid URL encoding' });
             return;
         }
+        // Explicit Traversal Guard: reject relative parent indicators or backslashes
+        if (decodedPath.includes('..') || decodedPath.includes('\\')) {
+            this.json(res, 403, { error: 'Access Denied: Path Traversal Prohibited' });
+            return;
+        }
+        const safePath = decodedPath === '/' ? 'index.html' : decodedPath.replace(/^\/+/, '');
+        const resolvedPath = path.resolve(normalizedDashboardDir, safePath);
+        // Strict Path Jailing: prevent directory traversal outside dashboardDir
+        const isWithinDashboard = resolvedPath.startsWith(normalizedDashboardDir + path.sep) ||
+            resolvedPath === path.join(normalizedDashboardDir, 'index.html');
+        if (!isWithinDashboard) {
+            this.json(res, 403, { error: 'Access Denied: Path Traversal Prohibited' });
+            return;
+        }
+        const filePath = resolvedPath;
         if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
             const ext = path.extname(filePath);
             const contentTypes = {
@@ -217,15 +438,17 @@ export class ControlApi {
             fs.createReadStream(filePath).pipe(res);
         }
         else {
-            // Fallback to index.html for SPA if exists
-            const indexPath = path.join(this.dashboardDir, 'index.html');
-            if (fs.existsSync(indexPath)) {
-                res.writeHead(200, { 'Content-Type': 'text/html' });
-                fs.createReadStream(indexPath).pipe(res);
-            }
-            else {
-                this.json(res, 404, { error: 'File not found' });
+            // Fallback to index.html for SPA only if requesting an extensionless path (e.g. client routes)
+            const ext = path.extname(filePath);
+            if (!ext) {
+                const indexPath = path.join(this.dashboardDir, 'index.html');
+                if (fs.existsSync(indexPath)) {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    fs.createReadStream(indexPath).pipe(res);
+                    return;
+                }
             }
+            this.json(res, 404, { error: 'File not found' });
         }
     }
     readBody(req) {
@@ -240,6 +463,65 @@ export class ControlApi {
         res.writeHead(status, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify(data));
     }
+    sampleProcess;
+    async restartSampleBackend() {
+        if (this.sampleProcess) {
+            try {
+                this.sampleProcess.kill();
+            }
+            catch { }
+            this.sampleProcess = undefined;
+        }
+        this.killPort(5050);
+        await new Promise((r) => setTimeout(r, 400));
+        const sampleScript = path.resolve(process.cwd(), 'examples/vulnerable-backend/server.js');
+        if (!fs.existsSync(sampleScript)) {
+            return;
+        }
+        const child = spawn(process.execPath, [sampleScript], {
+            cwd: path.dirname(sampleScript),
+            stdio: 'ignore',
+            detached: false,
+        });
+        this.sampleProcess = child;
+        const deadline = Date.now() + 6000;
+        while (Date.now() < deadline) {
+            try {
+                const res = await fetch('http://127.0.0.1:5050/api/health', {
+                    signal: AbortSignal.timeout(500),
+                });
+                if (res.ok) {
+                    return;
+                }
+            }
+            catch { }
+            await new Promise((r) => setTimeout(r, 200));
+        }
+    }
+    killPort(port) {
+        try {
+            if (process.platform === 'win32') {
+                const output = execSync(`netstat -ano | findstr :${port}`, { encoding: 'utf8' }).trim();
+                if (output) {
+                    const lines = output.split('\n');
+                    for (const line of lines) {
+                        const parts = line.trim().split(/\s+/);
+                        const pid = parts[parts.length - 1];
+                        if (pid && pid !== '0' && pid !== String(process.pid)) {
+                            try {
+                                execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore' });
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            }
+            else {
+                execSync(`fuser -k ${port}/tcp 2>/dev/null || true`, { stdio: 'ignore' });
+            }
+        }
+        catch { }
+    }
     start() {
         return new Promise((resolve, reject) => {
             this.server.listen(this.port, () => {
@@ -254,6 +536,14 @@ export class ControlApi {
         });
     }
     stop() {
+        if (this.sampleProcess) {
+            try {
+                this.sampleProcess.kill();
+            }
+            catch { }
+            this.sampleProcess = undefined;
+        }
+        this.killPort(5050);
         return new Promise((resolve) => {
             if (!this.isRunning)
                 return resolve();

package/dist/engine/FaultMeshProxy.d.ts

@@ -13,4 +13,6 @@ export declare class FaultMeshProxy {
     start(): Promise<void>;
     stop(): Promise<void>;
     getPort(): number;
+    setTargetUrl(url: string): void;
+    getTargetUrl(): string;
 }

package/dist/engine/FaultMeshProxy.js

@@ -28,8 +28,9 @@ export class FaultMeshProxy {
             res.end();
             return;
         }
+        const requestPath = req.url || '/';
         // 1. Check for immediate downstream Status override toxic
-        const statusToxic = this.toxicPipeline.getActiveStatusToxic('downstream');
+        const statusToxic = this.toxicPipeline.getActiveStatusToxic('downstream', requestPath);
         if (statusToxic) {
             appliedToxics.push(`Status (${statusToxic.statusCode})`);
             const body = statusToxic.responseBody || JSON.stringify({
@@ -37,11 +38,32 @@ export class FaultMeshProxy {
                 code: statusToxic.statusCode,
                 faultMesh: true,
             });
-            res.writeHead(statusToxic.statusCode, {
+            // Check if there is also an active downstream latency toxic
+            const latencyRule = this.toxicPipeline.getRules().find(r => r.enabled &&
+                r.type === 'latency' &&
+                r.direction === 'downstream' &&
+                (!r.pathPattern || !r.pathPattern.trim() || requestPath.includes(r.pathPattern.trim())));
+            if (latencyRule && latencyRule.config) {
+                const lCfg = latencyRule.config;
+                let delay = Math.max(0, lCfg.latencyMs || 0);
+                if (lCfg.jitterMs) {
+                    const jitter = (Math.random() * 2 - 1) * lCfg.jitterMs;
+                    delay = Math.max(0, Math.round(delay + jitter));
+                }
+                if (delay > 0) {
+                    appliedToxics.push(`Latency (${delay}ms)`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+            const headers = {
                 'Content-Type': 'application/json',
                 'X-FaultMesh-Injected': 'status',
                 'Access-Control-Allow-Origin': '*',
-            });
+            };
+            if (statusToxic.statusCode === 429) {
+                headers['Retry-After'] = '15';
+            }
+            res.writeHead(statusToxic.statusCode, headers);
             res.end(body);
             this.telemetryHub.recordRequestComplete({
                 id: requestId,
@@ -58,17 +80,25 @@ export class FaultMeshProxy {
         }
         // 2. Prepare Upstream forwarding
         const targetUrl = new URL(req.url || '/', this.config.targetUrl);
+        const clientHost = req.headers['host'];
+        const forwardedHost = clientHost && !clientHost.includes('3001')
+            ? clientHost
+            : targetUrl.host;
         const options = {
             protocol: targetUrl.protocol,
             hostname: targetUrl.hostname,
             port: targetUrl.port,
             path: targetUrl.pathname + targetUrl.search,
             method: req.method,
-            headers: { ...req.headers, host: targetUrl.host },
+            headers: {
+                ...req.headers,
+                host: forwardedHost,
+                'x-forwarded-host': clientHost || targetUrl.host,
+            },
         };
         const upstreamReq = http.request(options, async (upstreamRes) => {
             // 3. Prepare Downstream transformers
-            const { transformers: downstreamTransformers, appliedNames } = this.toxicPipeline.createStreamTransformers('downstream');
+            const { transformers: downstreamTransformers, appliedNames } = this.toxicPipeline.createStreamTransformers('downstream', requestPath);
             appliedToxics.push(...appliedNames);
             const headers = { ...upstreamRes.headers };
             delete headers['content-length']; // Length changes if chunks are compressed, cut, or padded
@@ -164,4 +194,10 @@ export class FaultMeshProxy {
     getPort() {
         return this.port;
     }
+    setTargetUrl(url) {
+        this.config.targetUrl = url;
+    }
+    getTargetUrl() {
+        return this.config.targetUrl;
+    }
 }

package/dist/engine/TelemetryHub.d.ts

@@ -11,6 +11,7 @@ export declare class TelemetryHub {
     getMetrics(): ProxyMetrics;
     getRecentEvents(): TelemetryEvent[];
     registerSSEClient(res: ServerResponse): void;
+    broadcastCustomEvent(eventType: string, data: any): void;
     private broadcastSSE;
     clear(): void;
 }

package/dist/engine/TelemetryHub.js

@@ -42,6 +42,9 @@ export class TelemetryHub {
             this.sseClients.delete(res);
         });
     }
+    broadcastCustomEvent(eventType, data) {
+        this.broadcastSSE(eventType, data);
+    }
     broadcastSSE(eventType, data) {
         const payload = `event: ${eventType}\ndata: ${JSON.stringify(data)}\n\n`;
         for (const client of this.sseClients) {

package/dist/engine/ToxicPipeline.d.ts

@@ -8,14 +8,15 @@ export declare class ToxicPipeline {
     getRules(): ToxicRule[];
     getRule(id: string): ToxicRule | undefined;
     clearRules(): void;
+    private matchesPath;
     /**
-     * Check if any active StatusToxic exists for the specified direction
+     * Check if any active StatusToxic exists for the specified direction and request path
      */
-    getActiveStatusToxic(direction: ToxicStreamDirection): StatusToxic | null;
+    getActiveStatusToxic(direction: ToxicStreamDirection, requestPath?: string): StatusToxic | null;
     /**
-     * Create an array of streaming transformers for the specified stream direction
+     * Create an array of streaming transformers for the specified stream direction and request path
      */
-    createStreamTransformers(direction: ToxicStreamDirection): {
+    createStreamTransformers(direction: ToxicStreamDirection, requestPath?: string): {
         transformers: Transform[];
         appliedNames: string[];
     };

package/dist/engine/ToxicPipeline.js

@@ -20,26 +20,39 @@ export class ToxicPipeline {
     clearRules() {
         this.rules.clear();
     }
+    matchesPath(rule, requestPath) {
+        if (!rule.pathPattern || !rule.pathPattern.trim()) {
+            return true;
+        }
+        if (!requestPath) {
+            return true;
+        }
+        return requestPath.includes(rule.pathPattern.trim());
+    }
     /**
-     * Check if any active StatusToxic exists for the specified direction
+     * Check if any active StatusToxic exists for the specified direction and request path
      */
-    getActiveStatusToxic(direction) {
+    getActiveStatusToxic(direction, requestPath) {
         for (const rule of this.rules.values()) {
             if (rule.enabled && rule.type === 'status' && rule.direction === direction) {
+                if (!this.matchesPath(rule, requestPath))
+                    continue;
                 return new StatusToxic(rule.config);
             }
         }
         return null;
     }
     /**
-     * Create an array of streaming transformers for the specified stream direction
+     * Create an array of streaming transformers for the specified stream direction and request path
      */
-    createStreamTransformers(direction) {
+    createStreamTransformers(direction, requestPath) {
         const transformers = [];
         const appliedNames = [];
         for (const rule of this.rules.values()) {
             if (!rule.enabled || rule.direction !== direction)
                 continue;
+            if (!this.matchesPath(rule, requestPath))
+                continue;
             switch (rule.type) {
                 case 'latency':
                     transformers.push(new LatencyToxic(rule.config));

package/dist/healer/AiHealer.d.ts

@@ -0,0 +1,30 @@
+import { AiProviderConfig, BackendFramework } from './types.js';
+export interface AiRemediationResult {
+    success: boolean;
+    content: string;
+    description: string;
+    error?: string;
+}
+export declare class AiHealer {
+    /**
+     * Checks if an AI provider is reachable or configured
+     */
+    static isAvailable(config?: AiProviderConfig): Promise<{
+        available: boolean;
+        provider?: string;
+    }>;
+    /**
+     * Generates a surgical code remediation using the configured or detected LLM provider
+     */
+    static generateRemediation(options: {
+        filePath: string;
+        originalContent: string;
+        framework: BackendFramework;
+        failedChecks: string[];
+        config?: AiProviderConfig;
+    }): Promise<AiRemediationResult>;
+    /**
+     * Safely strips enclosing markdown code fences from model outputs
+     */
+    private static extractCodeBlock;
+}