micro-models-agent 0.28.9 → 0.29.0

package/dist/modules/execution/verifier.js

@@ -0,0 +1,149 @@
+import { existsSync } from 'fs';
+import { resolve, extname } from 'path';
+import { execSync } from 'child_process';
+import { t } from '../../i18n/index';
+import { validateExpertConfig } from '../../config/experts';
+export class StepVerifier {
+    baseDir;
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+    }
+    async checkFileExists(path) {
+        const resolved = resolve(this.baseDir, path);
+        const exists = existsSync(resolved);
+        return {
+            passed: exists,
+            message: exists ? t('verify.file_exists', { path }) : t('verify.file_not_found', { path }),
+        };
+    }
+    async runScript(scriptName) {
+        try {
+            execSync(`bun run ${scriptName}`, {
+                cwd: this.baseDir,
+                encoding: 'utf-8',
+                timeout: 60_000,
+                stdio: 'pipe',
+            });
+            return { passed: true, message: t('verify.script_passed', { script: scriptName }) };
+        }
+        catch (e) {
+            return { passed: false, message: t('verify.script_failed', { script: scriptName, message: e.message }) };
+        }
+    }
+    async runTypeCheck() {
+        const tsconfigPath = resolve(this.baseDir, 'tsconfig.json');
+        if (!existsSync(tsconfigPath)) {
+            return { passed: true, message: 'No tsconfig.json found — skipping type check' };
+        }
+        try {
+            execSync('npx tsc --noEmit', {
+                cwd: this.baseDir,
+                encoding: 'utf-8',
+                timeout: 60_000,
+                stdio: 'pipe',
+            });
+            return { passed: true, message: 'TypeScript type check passed' };
+        }
+        catch (e) {
+            const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
+            return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
+        }
+    }
+    async runTests() {
+        const pkgPath = resolve(this.baseDir, 'package.json');
+        if (!existsSync(pkgPath)) {
+            return { passed: true, message: 'No package.json found — skipping tests' };
+        }
+        try {
+            const pkg = JSON.parse(require('fs').readFileSync(pkgPath, 'utf-8'));
+            if (!pkg.scripts?.test) {
+                return { passed: true, message: 'No test script defined — skipping tests' };
+            }
+        }
+        catch { /* fall through — attempt to run */ }
+        return this.runScript('test');
+    }
+    async verifyArtifactFiles(files) {
+        return Promise.all(files.map(f => this.checkFileExists(f)));
+    }
+    async verifyMoEManifest(plan, config, allToolTags) {
+        const errors = [];
+        const warnings = [];
+        const details = [];
+        const expertErrors = validateExpertConfig(config, allToolTags);
+        for (const err of expertErrors) {
+            errors.push(err);
+            details.push({ passed: false, message: err });
+        }
+        const tscResult = await this.runTypeCheck();
+        details.push(tscResult);
+        if (!tscResult.passed) {
+            errors.push(tscResult.message);
+        }
+        for (const sub of plan.subtasks) {
+            const fileChecks = await this.verifyArtifactFiles(sub.allowed_files || []);
+            for (const check of fileChecks) {
+                details.push(check);
+                if (!check.passed) {
+                    errors.push(check.message);
+                }
+            }
+        }
+        return {
+            success: errors.length === 0,
+            errors,
+            warnings,
+            details,
+        };
+    }
+    async verifyStep(stepDescription) {
+        const fileMatches = stepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || [];
+        const results = [];
+        let syntaxValid = true;
+        for (const filePath of fileMatches) {
+            const result = await this.checkFileExists(filePath);
+            results.push(result);
+            if (result.passed) {
+                const fullPath = resolve(this.baseDir, filePath);
+                if (!this.validateSyntax(fullPath)) {
+                    syntaxValid = false;
+                    results.push({ passed: false, message: t('verify.syntax_error', { path: filePath }) });
+                }
+            }
+        }
+        return {
+            passed: results.every(r => r.passed),
+            syntaxValid,
+            failed: results.filter(r => !r.passed),
+        };
+    }
+    validateSyntax(filePath) {
+        const ext = extname(filePath);
+        if (ext === '.ts' || ext === '.tsx') {
+            try {
+                execSync(`npx tsc --noEmit --skipLibCheck ${filePath}`, { stdio: 'pipe', timeout: 10000 });
+                return true;
+            }
+            catch (err) {
+                if (err.status === 127 || err.message.includes('not found') || err.message.includes('ENOENT')) {
+                    return true;
+                }
+                const stderr = err.stderr?.toString() || '';
+                if (stderr.includes('error TS') && !stderr.includes('Cannot find module')) {
+                    return false;
+                }
+                return true;
+            }
+        }
+        if (ext === '.js' || ext === '.jsx') {
+            try {
+                execSync(`node --check ${filePath}`, { stdio: 'pipe', timeout: 5000 });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/dist/modules/hallucination/confidence.js

@@ -0,0 +1,54 @@
+import { t } from "../../i18n/index";
+const MIN_CHARS = 1;
+const MIN_WORDS = 5;
+export class ConfidenceCheck {
+    previousResponse = "";
+    setPreviousResponse(response) {
+        this.previousResponse = response;
+    }
+    validate(response) {
+        if (!response || response.length < MIN_CHARS) {
+            return { status: "retry", reason: t("hall.short_response") };
+        }
+        // Language-agnostic: very short response with no structured content
+        const wordCount = response.split(/\s+/).filter(Boolean).length;
+        const hasStructure = /```|^\s*[-*]\s|^\s*\d+\.\s|<[^>]+>/m.test(response);
+        if (wordCount < MIN_WORDS && !hasStructure) {
+            return {
+                status: "warn",
+                reason: t("hall.short_response"),
+            };
+        }
+        // Language-agnostic: repetition detection via word overlap
+        if (this.previousResponse) {
+            const overlap = this.calculateOverlap(response, this.previousResponse);
+            if (overlap > 0.5) {
+                return {
+                    status: "retry",
+                    reason: t("hall.repetitive", { pct: Math.round(overlap * 100) }),
+                };
+            }
+        }
+        // Language-agnostic: very low word diversity (same words repeated)
+        const words = response.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+        if (words.length >= 10) {
+            const unique = new Set(words);
+            const diversity = unique.size / words.length;
+            if (diversity < 0.25) {
+                return {
+                    status: "warn",
+                    reason: t("hall.repetitive", { pct: Math.round((1 - diversity) * 100) }),
+                };
+            }
+        }
+        return { status: "pass" };
+    }
+    calculateOverlap(a, b) {
+        const wordsA = new Set(a.toLowerCase().split(/\s+/));
+        const wordsB = b.toLowerCase().split(/\s+/);
+        if (wordsB.length === 0)
+            return 0;
+        const matches = wordsB.filter((w) => wordsA.has(w));
+        return matches.length / wordsB.length;
+    }
+}

package/dist/modules/hallucination/consistency.js

@@ -0,0 +1,60 @@
+import { t } from '../../i18n/index';
+export class ConsistencyCheck {
+    decisions = [];
+    createdFiles = new Set();
+    deletedFiles = new Set();
+    trackDecision(decision, location) {
+        this.decisions.push({ decision, location });
+    }
+    trackCreatedFile(path) {
+        this.createdFiles.add(path);
+    }
+    trackDeletedFile(path) {
+        this.deletedFiles.add(path);
+    }
+    getCreatedFiles() {
+        return Array.from(this.createdFiles);
+    }
+    validate(response) {
+        const lower = response.toLowerCase();
+        for (const d of this.decisions) {
+            const decisionWords = d.decision.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+            const contradicts = decisionWords.some(word => {
+                // English patterns
+                if (lower.includes(`instead of ${word}`))
+                    return true;
+                if (lower.includes(`not ${word}`))
+                    return true;
+                if (lower.includes(`replacing ${word} with`))
+                    return true;
+                if (lower.includes(`switching to`))
+                    return true;
+                if (lower.includes(`changing from ${word}`))
+                    return true;
+                if (lower.includes(`abandoning ${word}`))
+                    return true;
+                // Russian patterns
+                if (lower.includes(`вместо ${word}`))
+                    return true;
+                if (lower.includes(`заменяя ${word}`))
+                    return true;
+                if (lower.includes(`заменяем ${word}`))
+                    return true;
+                if (lower.includes(`переключаемся на`))
+                    return true;
+                if (lower.includes(`от ${word} к`))
+                    return true;
+                if (lower.includes(`отказываемся от ${word}`))
+                    return true;
+                return false;
+            });
+            if (contradicts) {
+                return {
+                    status: 'warn',
+                    reason: t('hall.contradiction', { decision: d.decision, location: d.location }),
+                };
+            }
+        }
+        return { status: 'pass' };
+    }
+}

package/dist/modules/hallucination/detector.js

@@ -0,0 +1,41 @@
+import { FactualCheck } from './factual';
+import { ConsistencyCheck } from './consistency';
+import { ConfidenceCheck } from './confidence';
+export class HallucinationDetector {
+    factual;
+    consistency;
+    confidence;
+    constructor() {
+        this.factual = new FactualCheck();
+        this.consistency = new ConsistencyCheck();
+        this.confidence = new ConfidenceCheck();
+    }
+    getFactualCheck() {
+        return this.factual;
+    }
+    getConsistencyCheck() {
+        return this.consistency;
+    }
+    getConfidenceCheck() {
+        return this.confidence;
+    }
+    validate(response) {
+        const confidenceResult = this.confidence.validate(response);
+        if (confidenceResult.status === 'retry' || confidenceResult.status === 'block') {
+            return confidenceResult;
+        }
+        const factualResult = this.factual.validate(response);
+        const consistencyResult = this.consistency.validate(response);
+        const warnings = [];
+        if (factualResult.status === 'warn')
+            warnings.push(factualResult.reason || '');
+        if (consistencyResult.status === 'warn')
+            warnings.push(consistencyResult.reason || '');
+        if (confidenceResult.status === 'warn')
+            warnings.push(confidenceResult.reason || '');
+        if (warnings.length > 0) {
+            return { status: 'warn', reason: warnings.join('; ') };
+        }
+        return { status: 'pass' };
+    }
+}

package/dist/modules/hallucination/factual.js

@@ -0,0 +1,170 @@
+import { t } from "../../i18n/index";
+import { existsSync } from "fs";
+import { join } from "path";
+const FILE_EXTENSIONS = new Set([
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "mts",
+    "cts",
+    "json",
+    "md",
+    "yaml",
+    "yml",
+    "py",
+    "rs",
+    "go",
+    "java",
+    "c",
+    "cpp",
+    "h",
+    "hpp",
+    "html",
+    "css",
+    "scss",
+    "less",
+    "vue",
+    "svelte",
+    "sh",
+    "bash",
+    "zsh",
+    "ps1",
+    "bat",
+    "cmd",
+    "txt",
+    "env",
+    "env.local",
+    "env.production",
+    "gitignore",
+    "dockerignore",
+    "dockerfile",
+    "makefile",
+    "cmake",
+    "toml",
+    "lock",
+    "config",
+    "log",
+    "xml",
+    "sql",
+    "graphql",
+    "proto",
+    "wasm",
+]);
+const VERSION_PATTERN = /^\d+(\.\d+)*$/;
+const COMMON_WORDS = new Set([
+    "node.js", "Node.js",
+    "console.log", "console.error", "console.warn", "console.info",
+    "Math.floor", "Math.ceil", "Math.round", "Math.max", "Math.min",
+    "JSON.parse", "JSON.stringify",
+    "Object.keys", "Object.values", "Object.entries",
+    "Array.from", "Array.isArray",
+    "Date.now", "Date.parse",
+    "RegExp", "Promise",
+]);
+export class FactualCheck {
+    knownPaths = new Set();
+    createdPaths = new Set();
+    readFiles = new Set();
+    baseDir = process.cwd();
+    setBaseDir(dir) {
+        this.baseDir = dir;
+    }
+    trackReadPath(path) {
+        this.knownPaths.add(path);
+        const base = path.split(/[/\\]/).pop();
+        if (base && base !== path)
+            this.knownPaths.add(base);
+        // Track that this file was actually read by the agent
+        this.readFiles.add(base || path);
+    }
+    trackCreatedPath(path) {
+        this.knownPaths.add(path);
+        const base = path.split(/[/\\]/).pop();
+        if (base && base !== path)
+            this.knownPaths.add(base);
+        this.createdPaths.add(path);
+    }
+    trackDeletedPath(path) {
+        this.knownPaths.add(path);
+        const base = path.split(/[/\\]/).pop();
+        if (base && base !== path)
+            this.knownPaths.add(base);
+        this.createdPaths.delete(path);
+    }
+    /**
+     * Register file paths found in a document (e.g. structure.md, README).
+     * Files mentioned in project documentation are not hallucinations.
+     */
+    trackDocumentContent(content) {
+        // Match common path patterns in documentation
+        const pathPatterns = /(?:^|\s)([\w\-./]+\.\w{1,10})(?:\s|$|[,;)])/gm;
+        let match;
+        while ((match = pathPatterns.exec(content)) !== null) {
+            const file = match[1];
+            if (file.includes('/') || file.includes('\\')) {
+                this.knownPaths.add(file);
+            }
+            const base = file.split(/[/\\]/).pop();
+            if (base)
+                this.knownPaths.add(base);
+        }
+    }
+    pathExistsOnDisk(path) {
+        try {
+            // Skip absolute paths — they're either system paths or outside the project.
+            // On Windows, existsSync('/...') can hang on certain paths.
+            if (path.startsWith("/") || path.startsWith("~") || /^[A-Za-z]:/.test(path)) {
+                return false;
+            }
+            return existsSync(join(this.baseDir, path));
+        }
+        catch {
+            return false;
+        }
+    }
+    validate(response) {
+        const pathRegex = /[\w\-./]+\.\w+/g;
+        const mentionedPaths = response.match(pathRegex) || [];
+        const unknownPaths = mentionedPaths.filter((p) => {
+            if (this.knownPaths.has(p))
+                return false;
+            if (VERSION_PATTERN.test(p))
+                return false;
+            if (COMMON_WORDS.has(p))
+                return false;
+            // Skip absolute paths — agent responses use relative paths; absolute
+            // paths are either system paths or URLs, and existsSync can hang on
+            // Windows for root-relative paths like "/page.html".
+            if (p.startsWith("/") || p.startsWith("~") || /^[A-Za-z]:/.test(p))
+                return false;
+            if (this.pathExistsOnDisk(p))
+                return false;
+            const ext = p.split(".").pop()?.toLowerCase() || "";
+            if (!FILE_EXTENSIONS.has(ext))
+                return false;
+            const basename = p
+                .split("/")
+                .pop()
+                ?.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            if (basename) {
+                const urlPattern = new RegExp(`(https?|file)://[^\\s]*${basename}`);
+                if (urlPattern.test(response))
+                    return false;
+            }
+            return true;
+        });
+        if (unknownPaths.length > 0) {
+            const uniquePaths = [...new Set(unknownPaths)];
+            return {
+                status: "warn",
+                reason: t("hall.unknown_paths", {
+                    paths: uniquePaths.slice(0, 3).join(", "),
+                }),
+            };
+        }
+        return { status: "pass" };
+    }
+}

package/dist/modules/hallucination/index.js

@@ -0,0 +1,4 @@
+export { HallucinationDetector } from './detector';
+export { FactualCheck } from './factual';
+export { ConsistencyCheck } from './consistency';
+export { ConfidenceCheck } from './confidence';

package/dist/modules/index.js

@@ -0,0 +1,5 @@
+export { ModuleRegistry } from './registry';
+export { SkillsLoader, SkillsMatcher, SkillsModule } from './skills';
+export { PluginManager } from './plugins';
+export { PluginLoader } from './plugins/loader';
+export { MCPClient, MCPRegistry } from './mcp';

package/dist/modules/indexer/cache.js

@@ -0,0 +1,38 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync } from 'fs';
+import { join } from 'path';
+export class IndexCache {
+    cachePath;
+    cache = null;
+    constructor(cacheDir) {
+        this.cachePath = join(cacheDir, 'index-cache.json');
+    }
+    load() {
+        if (this.cache)
+            return this.cache;
+        if (!existsSync(this.cachePath))
+            return null;
+        try {
+            this.cache = JSON.parse(readFileSync(this.cachePath, 'utf-8'));
+            return this.cache;
+        }
+        catch {
+            return null;
+        }
+    }
+    save(result) {
+        this.cache = result;
+        const dir = join(this.cachePath, '..');
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(this.cachePath, JSON.stringify(result), 'utf-8');
+    }
+    invalidate() {
+        this.cache = null;
+        if (existsSync(this.cachePath)) {
+            try {
+                rmSync(this.cachePath);
+            }
+            catch { /* ignore */ }
+        }
+    }
+}

package/dist/modules/indexer/index.js

@@ -0,0 +1,3 @@
+export { Indexer } from './walker';
+export { IndexCache } from './cache';
+export { IndexerModule } from './module';