genesis-ai-cli 7.4.5

package/dist/src/grounding/feedback.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * Genesis Grounding Feedback Loop
+ *
+ * Iterative verification and fixing pipeline:
+ * 1. Generate code
+ * 2. Verify (compile, test, semantic)
+ * 3. If fails: pass errors to fixer
+ * 4. Regenerate with error context
+ * 5. Max N iterations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackLoop = void 0;
+exports.getFeedbackLoop = getFeedbackLoop;
+exports.resetFeedbackLoop = resetFeedbackLoop;
+exports.runFeedbackLoop = runFeedbackLoop;
+exports.verifyAndFix = verifyAndFix;
+exports.isProjectValid = isProjectValid;
+exports.formatFeedbackResult = formatFeedbackResult;
+const verifier_js_1 = require("./verifier.js");
+const fixer_js_1 = require("../healing/fixer.js");
+const DEFAULT_CONFIG = {
+    maxIterations: 3,
+    stopOnSuccess: true,
+    verificationContext: {
+        workingDirectory: process.cwd(),
+    },
+    enableAutoFix: true,
+    verbose: false,
+};
+// ============================================================================
+// FeedbackLoop Class
+// ============================================================================
+class FeedbackLoop {
+    config;
+    verifier;
+    fixer;
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.verifier = (0, verifier_js_1.getVerifier)();
+        this.fixer = (0, fixer_js_1.getAutoFixer)({
+            workingDirectory: this.config.verificationContext.workingDirectory,
+        });
+    }
+    /**
+     * Run the feedback loop
+     */
+    async run() {
+        const startTime = Date.now();
+        const history = [];
+        let success = false;
+        let finalResult = null;
+        for (let i = 1; i <= this.config.maxIterations; i++) {
+            const iterationStart = Date.now();
+            if (this.config.verbose) {
+                console.log(`\n[Iteration ${i}/${this.config.maxIterations}]`);
+            }
+            // Step 1: Verify
+            if (this.config.verbose) {
+                console.log('  Verifying...');
+            }
+            const verification = await this.verifier.verify(this.config.verificationContext);
+            finalResult = verification;
+            if (this.config.verbose) {
+                console.log(`  Compiles: ${verification.compiles ? '✓' : '✗'}`);
+                console.log(`  Types: ${verification.typesValid ? '✓' : '✗'}`);
+                console.log(`  Tests: ${verification.testsPass ? '✓' : '✗'} (${verification.testsPassed}/${verification.testsTotal})`);
+            }
+            // Check if successful
+            if (verification.success) {
+                if (this.config.verbose) {
+                    console.log('  Status: SUCCESS');
+                }
+                history.push({
+                    iteration: i,
+                    verification,
+                    duration: Date.now() - iterationStart,
+                    success: true,
+                });
+                success = true;
+                if (this.config.stopOnSuccess)
+                    break;
+                continue;
+            }
+            // Step 2: Auto-fix if enabled
+            let fixResult;
+            if (this.config.enableAutoFix && verification.issues.length > 0) {
+                if (this.config.verbose) {
+                    console.log(`  Attempting auto-fix for ${verification.issues.length} issues...`);
+                }
+                // Convert grounding issues to detected errors
+                const errors = verification.issues.map(issue => ({
+                    category: this.mapIssueType(issue.type),
+                    severity: issue.severity,
+                    message: issue.message,
+                    file: issue.file,
+                    line: issue.line,
+                    raw: issue.message,
+                    fixHint: issue.suggestion,
+                }));
+                fixResult = await this.fixer.fix(errors);
+                if (this.config.verbose) {
+                    console.log(`  Fix result: ${fixResult.success ? 'SUCCESS' : 'FAILED'}`);
+                    if (fixResult.appliedFix) {
+                        console.log(`  Fix applied: ${fixResult.appliedFix.description}`);
+                    }
+                }
+            }
+            history.push({
+                iteration: i,
+                verification,
+                fix: fixResult,
+                duration: Date.now() - iterationStart,
+                success: false,
+            });
+        }
+        // Ensure we have a final result
+        if (!finalResult) {
+            finalResult = await this.verifier.verify(this.config.verificationContext);
+        }
+        const totalDuration = Date.now() - startTime;
+        // Generate summary
+        const summary = this.generateSummary(success, history, totalDuration);
+        return {
+            success,
+            iterations: history.length,
+            history,
+            finalResult,
+            totalDuration,
+            summary,
+        };
+    }
+    /**
+     * Run verification only (no fixing)
+     */
+    async verifyOnly() {
+        return this.verifier.verify(this.config.verificationContext);
+    }
+    /**
+     * Map grounding issue type to error category
+     */
+    mapIssueType(type) {
+        switch (type) {
+            case 'compile':
+                return 'build';
+            case 'type':
+                return 'type';
+            case 'test':
+                return 'test';
+            case 'lint':
+                return 'lint';
+            default:
+                return 'unknown';
+        }
+    }
+    /**
+     * Generate summary message
+     */
+    generateSummary(success, history, duration) {
+        if (success) {
+            const successIteration = history.findIndex(h => h.success) + 1;
+            if (successIteration === 1) {
+                return `Verification passed on first attempt (${duration}ms)`;
+            }
+            return `Verification passed after ${successIteration} iterations with ${history.filter(h => h.fix?.appliedFix).length} fixes (${duration}ms)`;
+        }
+        const totalIssues = history[history.length - 1]?.verification.issues.length || 0;
+        const totalFixes = history.filter(h => h.fix?.appliedFix).length;
+        return `Verification failed after ${history.length} iterations. ${totalIssues} issues remaining, ${totalFixes} fixes attempted (${duration}ms)`;
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        if (updates.verificationContext) {
+            this.fixer = (0, fixer_js_1.getAutoFixer)({
+                workingDirectory: updates.verificationContext.workingDirectory,
+            });
+        }
+    }
+    /**
+     * Get current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+}
+exports.FeedbackLoop = FeedbackLoop;
+// ============================================================================
+// Singleton Instance
+// ============================================================================
+let feedbackLoopInstance = null;
+function getFeedbackLoop(config) {
+    if (!feedbackLoopInstance) {
+        feedbackLoopInstance = new FeedbackLoop(config);
+    }
+    else if (config) {
+        feedbackLoopInstance.updateConfig(config);
+    }
+    return feedbackLoopInstance;
+}
+function resetFeedbackLoop() {
+    feedbackLoopInstance = null;
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Run feedback loop with default configuration
+ */
+async function runFeedbackLoop(workingDirectory, options) {
+    const loop = new FeedbackLoop({
+        ...options,
+        verificationContext: {
+            workingDirectory,
+        },
+    });
+    return loop.run();
+}
+/**
+ * Verify and fix until success or max iterations
+ */
+async function verifyAndFix(workingDirectory, maxIterations = 3) {
+    return runFeedbackLoop(workingDirectory, { maxIterations });
+}
+/**
+ * Quick check if code is currently valid
+ */
+async function isProjectValid(workingDirectory) {
+    const loop = new FeedbackLoop({
+        verificationContext: { workingDirectory },
+        maxIterations: 1,
+        enableAutoFix: false,
+    });
+    const result = await loop.run();
+    return result.success;
+}
+/**
+ * Format feedback loop result for display
+ */
+function formatFeedbackResult(result) {
+    const lines = [];
+    // Header
+    const status = result.success ? '✓ SUCCESS' : '✗ FAILED';
+    lines.push(`Feedback Loop ${status}`);
+    lines.push(`${result.summary}`);
+    lines.push('');
+    // Iteration history
+    lines.push('Iteration History:');
+    for (const iter of result.history) {
+        const iterStatus = iter.success ? '✓' : '✗';
+        const fixInfo = iter.fix?.appliedFix ? ' (1 fix)' : '';
+        lines.push(`  ${iter.iteration}. ${iterStatus} ${iter.verification.issues.length} issues${fixInfo} [${iter.duration}ms]`);
+    }
+    lines.push('');
+    // Final state
+    lines.push('Final State:');
+    lines.push(`  Compiles:  ${result.finalResult.compiles ? '✓' : '✗'}`);
+    lines.push(`  Types:     ${result.finalResult.typesValid ? '✓' : '✗'}`);
+    lines.push(`  Tests:     ${result.finalResult.testsPass ? '✓' : '✗'} (${result.finalResult.testsPassed}/${result.finalResult.testsTotal})`);
+    lines.push(`  Semantic:  ${(result.finalResult.semanticMatch * 100).toFixed(0)}%`);
+    // Remaining issues
+    if (result.finalResult.issues.length > 0 && !result.success) {
+        lines.push('');
+        lines.push(`Remaining Issues (${result.finalResult.issues.length}):`);
+        for (const issue of result.finalResult.issues.slice(0, 5)) {
+            const prefix = issue.severity === 'error' ? '✗' : '⚠';
+            lines.push(`  ${prefix} ${issue.message}`);
+        }
+        if (result.finalResult.issues.length > 5) {
+            lines.push(`  ... and ${result.finalResult.issues.length - 5} more`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/src/grounding/index.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Genesis 6.0 - Grounding Module
+ *
+ * Epistemic foundation for all claims and decisions:
+ *
+ * 1. SCIENCE - factual/empirical (arxiv, semantic-scholar, web)
+ * 2. PROOF - mathematical/logical (wolfram, type-check)
+ * 3. WISDOM - practical heuristics (repository + patterns)
+ * 4. RELIGION/TRADITION - meaning and morals (repository)
+ * 5. HUMAN - preferences and final authority
+ * 6. PRUDENCE - acting under uncertainty
+ *
+ * Usage:
+ * ```typescript
+ * import { createGroundingSystem } from './grounding/index.js';
+ *
+ * const grounding = createGroundingSystem();
+ *
+ * // Ground a factual claim
+ * const fact = await grounding.ground('TypeScript is a typed superset of JavaScript');
+ * // → verified via science
+ *
+ * // Ground an ethical question
+ * const ethics = await grounding.ground('Should I release this code?');
+ * // → requires human consultation via wisdom
+ *
+ * // Ground a novel situation
+ * const novel = await grounding.ground('How should I handle this unprecedented bug?');
+ * // → prudence + human
+ * ```
+ */
+export * from './epistemic-stack.js';
+export * from './verifier.js';
+export * from './feedback.js';
+import { EpistemicClaim, EpistemicDomain, GroundingResult, WisdomSource, TraditionSource } from './epistemic-stack.js';
+export interface GroundingConfig {
+    scienceEnabled?: boolean;
+    proofEnabled?: boolean;
+    wisdomEnabled?: boolean;
+    traditionEnabled?: boolean;
+    humanEnabled?: boolean;
+    defaultToHumanOnUncertainty?: boolean;
+    uncertaintyThreshold?: number;
+}
+export declare class GroundingSystem {
+    private config;
+    private stack;
+    private claimsGrounded;
+    private humanConsultations;
+    private byDomain;
+    constructor(config?: Partial<GroundingConfig>);
+    /**
+     * Connect science grounding to MCP servers
+     */
+    connectScience(grounter: (claim: string) => Promise<GroundingResult>): void;
+    /**
+     * Connect proof checking
+     */
+    connectProof(checker: (claim: string) => Promise<GroundingResult>): void;
+    /**
+     * Ground a claim through the full epistemic stack
+     */
+    ground(claim: string): Promise<EpistemicClaim>;
+    /**
+     * Quick check: does this claim need human input?
+     */
+    needsHuman(claim: EpistemicClaim): boolean;
+    /**
+     * Get the question to ask the human
+     */
+    getQuestion(claim: EpistemicClaim): string | undefined;
+    /**
+     * Process human response
+     */
+    respondHuman(claim: EpistemicClaim, response: string): EpistemicClaim;
+    /**
+     * Get statistics
+     */
+    stats(): {
+        claimsGrounded: number;
+        humanConsultations: number;
+        humanRate: number;
+        byDomain: Record<EpistemicDomain, number>;
+    };
+    /**
+     * Get all wisdom sources
+     */
+    getWisdom(): WisdomSource[];
+    /**
+     * Get all tradition sources
+     */
+    getTraditions(): TraditionSource[];
+    /**
+     * Add custom wisdom
+     */
+    addWisdom(wisdom: WisdomSource): void;
+    /**
+     * Add custom tradition
+     */
+    addTradition(tradition: TraditionSource): void;
+}
+export declare function createGroundingSystem(config?: Partial<GroundingConfig>): GroundingSystem;
+export declare function getGroundingSystem(config?: Partial<GroundingConfig>): GroundingSystem;
+export declare function resetGroundingSystem(): void;
+import { verifyCode, quickVerify, isCodeValid, formatVerificationResult, getVerifier, resetVerifier } from './verifier.js';
+import { runFeedbackLoop, verifyAndFix, isProjectValid, formatFeedbackResult, getFeedbackLoop, resetFeedbackLoop } from './feedback.js';
+/**
+ * Code verification and feedback loop utilities
+ */
+export declare const codeGrounding: {
+    verify: typeof verifyCode;
+    quickVerify: typeof quickVerify;
+    isCodeValid: typeof isCodeValid;
+    formatResult: typeof formatVerificationResult;
+    getVerifier: typeof getVerifier;
+    resetVerifier: typeof resetVerifier;
+    runLoop: typeof runFeedbackLoop;
+    verifyAndFix: typeof verifyAndFix;
+    isProjectValid: typeof isProjectValid;
+    formatLoopResult: typeof formatFeedbackResult;
+    getLoop: typeof getFeedbackLoop;
+    resetLoop: typeof resetFeedbackLoop;
+};

package/dist/src/grounding/index.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * Genesis 6.0 - Grounding Module
+ *
+ * Epistemic foundation for all claims and decisions:
+ *
+ * 1. SCIENCE - factual/empirical (arxiv, semantic-scholar, web)
+ * 2. PROOF - mathematical/logical (wolfram, type-check)
+ * 3. WISDOM - practical heuristics (repository + patterns)
+ * 4. RELIGION/TRADITION - meaning and morals (repository)
+ * 5. HUMAN - preferences and final authority
+ * 6. PRUDENCE - acting under uncertainty
+ *
+ * Usage:
+ * ```typescript
+ * import { createGroundingSystem } from './grounding/index.js';
+ *
+ * const grounding = createGroundingSystem();
+ *
+ * // Ground a factual claim
+ * const fact = await grounding.ground('TypeScript is a typed superset of JavaScript');
+ * // → verified via science
+ *
+ * // Ground an ethical question
+ * const ethics = await grounding.ground('Should I release this code?');
+ * // → requires human consultation via wisdom
+ *
+ * // Ground a novel situation
+ * const novel = await grounding.ground('How should I handle this unprecedented bug?');
+ * // → prudence + human
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeGrounding = exports.GroundingSystem = void 0;
+exports.createGroundingSystem = createGroundingSystem;
+exports.getGroundingSystem = getGroundingSystem;
+exports.resetGroundingSystem = resetGroundingSystem;
+// Re-export everything from epistemic stack
+__exportStar(require("./epistemic-stack.js"), exports);
+// Re-export verifier and feedback loop
+__exportStar(require("./verifier.js"), exports);
+__exportStar(require("./feedback.js"), exports);
+const epistemic_stack_js_1 = require("./epistemic-stack.js");
+const DEFAULT_CONFIG = {
+    scienceEnabled: true,
+    proofEnabled: true,
+    wisdomEnabled: true,
+    traditionEnabled: true,
+    humanEnabled: true,
+    defaultToHumanOnUncertainty: false, // v7.2: Disabled by default (too aggressive without connected grounders)
+    uncertaintyThreshold: 0.2, // v7.2: Lowered from 0.5 - only flag truly uncertain claims
+};
+class GroundingSystem {
+    config;
+    stack;
+    // Stats
+    claimsGrounded = 0;
+    humanConsultations = 0;
+    byDomain = {
+        factual: 0,
+        mathematical: 0,
+        ethical: 0,
+        existential: 0,
+        aesthetic: 0,
+        novel: 0,
+    };
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.stack = (0, epistemic_stack_js_1.createEpistemicStack)();
+    }
+    /**
+     * Connect science grounding to MCP servers
+     */
+    connectScience(grounter) {
+        if (this.config.scienceEnabled) {
+            this.stack.setScienceGrounder(grounter);
+        }
+    }
+    /**
+     * Connect proof checking
+     */
+    connectProof(checker) {
+        if (this.config.proofEnabled) {
+            this.stack.setProofChecker(checker);
+        }
+    }
+    /**
+     * Ground a claim through the full epistemic stack
+     */
+    async ground(claim) {
+        const result = await this.stack.ground(claim);
+        // Track stats
+        this.claimsGrounded++;
+        this.byDomain[result.domain]++;
+        if (result.grounding.humanConsultation?.required) {
+            this.humanConsultations++;
+        }
+        // Check if we need to escalate to human due to uncertainty
+        if (this.config.defaultToHumanOnUncertainty &&
+            result.confidence < this.config.uncertaintyThreshold &&
+            !result.grounding.humanConsultation?.required) {
+            result.grounding.humanConsultation = {
+                required: true,
+                reason: `Confidence ${(result.confidence * 100).toFixed(0)}% below threshold ${(this.config.uncertaintyThreshold * 100).toFixed(0)}%`,
+                question: `Incertezza su: "${claim}". Vuoi procedere comunque?`,
+            };
+            this.humanConsultations++;
+        }
+        return result;
+    }
+    /**
+     * Quick check: does this claim need human input?
+     */
+    needsHuman(claim) {
+        return this.stack.requiresHuman(claim);
+    }
+    /**
+     * Get the question to ask the human
+     */
+    getQuestion(claim) {
+        return this.stack.getHumanQuestion(claim);
+    }
+    /**
+     * Process human response
+     */
+    respondHuman(claim, response) {
+        return this.stack.incorporateHumanResponse(claim, response);
+    }
+    /**
+     * Get statistics
+     */
+    stats() {
+        return {
+            claimsGrounded: this.claimsGrounded,
+            humanConsultations: this.humanConsultations,
+            humanRate: this.claimsGrounded > 0
+                ? this.humanConsultations / this.claimsGrounded
+                : 0,
+            byDomain: { ...this.byDomain },
+        };
+    }
+    /**
+     * Get all wisdom sources
+     */
+    getWisdom() {
+        return [...epistemic_stack_js_1.WISDOM_REPOSITORY];
+    }
+    /**
+     * Get all tradition sources
+     */
+    getTraditions() {
+        return [...epistemic_stack_js_1.TRADITION_REPOSITORY];
+    }
+    /**
+     * Add custom wisdom
+     */
+    addWisdom(wisdom) {
+        epistemic_stack_js_1.WISDOM_REPOSITORY.push(wisdom);
+    }
+    /**
+     * Add custom tradition
+     */
+    addTradition(tradition) {
+        epistemic_stack_js_1.TRADITION_REPOSITORY.push(tradition);
+    }
+}
+exports.GroundingSystem = GroundingSystem;
+// ============================================================================
+// Factory
+// ============================================================================
+function createGroundingSystem(config) {
+    return new GroundingSystem(config);
+}
+// ============================================================================
+// Singleton
+// ============================================================================
+let groundingInstance = null;
+function getGroundingSystem(config) {
+    if (!groundingInstance) {
+        groundingInstance = createGroundingSystem(config);
+    }
+    return groundingInstance;
+}
+function resetGroundingSystem() {
+    groundingInstance = null;
+}
+// ============================================================================
+// Code Verification (from verifier.ts)
+// ============================================================================
+const verifier_js_1 = require("./verifier.js");
+const feedback_js_1 = require("./feedback.js");
+/**
+ * Code verification and feedback loop utilities
+ */
+exports.codeGrounding = {
+    // Verification
+    verify: verifier_js_1.verifyCode,
+    quickVerify: verifier_js_1.quickVerify,
+    isCodeValid: verifier_js_1.isCodeValid,
+    formatResult: verifier_js_1.formatVerificationResult,
+    getVerifier: verifier_js_1.getVerifier,
+    resetVerifier: verifier_js_1.resetVerifier,
+    // Feedback Loop
+    runLoop: feedback_js_1.runFeedbackLoop,
+    verifyAndFix: feedback_js_1.verifyAndFix,
+    isProjectValid: feedback_js_1.isProjectValid,
+    formatLoopResult: feedback_js_1.formatFeedbackResult,
+    getLoop: feedback_js_1.getFeedbackLoop,
+    resetLoop: feedback_js_1.resetFeedbackLoop,
+};