micro-models-agent 0.7.10 → 0.9.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,47 @@
+import { t } from "../../i18n/index";
+const UNCERTAINTY_MARKERS = [
+    "i think",
+    "maybe",
+    "probably",
+    "i believe",
+    "not sure",
+    "might be",
+];
+const MIN_CHARS = 1;
+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") };
+        }
+        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) }),
+                };
+            }
+        }
+        const lower = response.toLowerCase();
+        const foundMarkers = UNCERTAINTY_MARKERS.filter((m) => lower.includes(m));
+        if (foundMarkers.length > 0) {
+            return {
+                status: "warn",
+                reason: t("hall.uncertainty", { markers: foundMarkers.join(", ") }),
+            };
+        }
+        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,32 @@
+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 => lower.includes(`instead of ${word}`) || lower.includes(`not ${word}`));
+            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,128 @@
+import { t } from "../../i18n/index";
+import { existsSync } from "fs";
+import { join } from "path";
+const FILE_EXTENSIONS = new Set([
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "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",
+    "gitignore",
+    "dockerignore",
+    "dockerfile",
+    "makefile",
+    "cmake",
+    "toml",
+    "xml",
+    "sql",
+    "graphql",
+    "proto",
+    "wasm",
+]);
+const VERSION_PATTERN = /^\d+(\.\d+)*$/;
+const COMMON_WORDS = new Set(["node.js", "Node.js"]);
+export class FactualCheck {
+    knownPaths = new Set();
+    createdPaths = 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);
+    }
+    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);
+    }
+    pathExistsOnDisk(path) {
+        try {
+            if (path.startsWith("/") ||
+                path.startsWith("~") ||
+                /^[A-Za-z]:/.test(path)) {
+                return existsSync(path);
+            }
+            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 (p.startsWith("/"))
+                return false;
+            if (COMMON_WORDS.has(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';

package/dist/modules/indexer/module.js

@@ -0,0 +1,192 @@
+import { dirname } from 'path';
+import { Indexer } from './walker';
+import { IndexCache } from './cache';
+import { t } from '../../i18n/index';
+export class IndexerModule {
+    name = 'indexer';
+    indexer;
+    cache;
+    baseDir;
+    index = null;
+    rebuildTimeout = null;
+    constructor(opts) {
+        this.baseDir = opts.baseDir;
+        this.indexer = new Indexer(opts.baseDir);
+        this.cache = new IndexCache(opts.cacheDir);
+    }
+    async buildIndex() {
+        if (this.index)
+            return this.index;
+        const cached = this.cache.load();
+        if (cached) {
+            this.index = cached;
+            return cached;
+        }
+        try {
+            const result = await this.indexer.walk();
+            this.cache.save(result);
+            this.index = result;
+            return result;
+        }
+        catch {
+            return null;
+        }
+    }
+    async refresh() {
+        this.cache.invalidate();
+        this.index = null;
+        return this.buildIndex();
+    }
+    find(query) {
+        if (!this.index)
+            return [];
+        const q = query.toLowerCase();
+        return this.index.files.filter((f) => {
+            const path = f.path.toLowerCase();
+            return path.includes(q) || f.exports.some((e) => e.toLowerCase().includes(q));
+        });
+    }
+    watch() {
+        this.unwatch();
+        try {
+            this.indexer.watch((_event, filename) => {
+                if (!filename)
+                    return;
+                if (this.rebuildTimeout)
+                    clearTimeout(this.rebuildTimeout);
+                this.rebuildTimeout = setTimeout(() => {
+                    this.refresh().catch(() => { });
+                }, 2000);
+            });
+        }
+        catch {
+            // Watching is best-effort; manual refresh still works.
+        }
+    }
+    unwatch() {
+        if (this.rebuildTimeout) {
+            clearTimeout(this.rebuildTimeout);
+            this.rebuildTimeout = null;
+        }
+        this.indexer.unwatch();
+    }
+    getSystemPromptBlock() {
+        if (!this.index)
+            return null;
+        const content = this.formatMap(this.index);
+        return {
+            content,
+            priority: 'normal',
+            essential: false,
+            estimatedTokens: this.estimateTokens(content),
+        };
+    }
+    getToolDefinitions() {
+        return [this.createProjectMapTool()];
+    }
+    getPlugin() {
+        return {
+            name: 'indexer',
+            onSessionStart: () => {
+                this.buildIndex().catch(() => { });
+                this.watch();
+            },
+            onSessionEnd: () => {
+                this.unwatch();
+            },
+        };
+    }
+    formatMap(result) {
+        const summary = this.indexer.summarize(result);
+        const dirCounts = this.getDirectoryCounts(result);
+        const topDirs = Object.entries(dirCounts)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([dir, count]) => `${dir} (${count})`)
+            .join(', ') || '-';
+        const fileLines = result.files.slice(0, 100).map((f) => {
+            const path = f.path.replace(/\\/g, '/');
+            const exports = f.exports.length > 0 ? `: ${f.exports.join(', ')}` : '';
+            return `- ${path}${exports}`;
+        });
+        const more = result.files.length > 100
+            ? `\n${t('indexer.and_more', { count: result.files.length - 100 })}`
+            : '';
+        return [
+            `${t('indexer.map_header')} (${this.baseDir})`,
+            summary,
+            `${t('indexer.top_directories')}: ${topDirs}`,
+            `${t('indexer.files')}:` + (fileLines.length > 0 ? '' : ' ' + t('indexer.empty')),
+            ...fileLines,
+            more,
+        ].join('\n');
+    }
+    getDirectoryCounts(result) {
+        const counts = {};
+        for (const f of result.files) {
+            const normalized = f.path.replace(/\\/g, '/');
+            const dir = dirname(normalized);
+            const key = dir === '.' ? '(root)' : dir;
+            counts[key] = (counts[key] || 0) + 1;
+        }
+        return counts;
+    }
+    estimateTokens(content) {
+        return Math.ceil(content.length / 4);
+    }
+    createProjectMapTool() {
+        return {
+            name: 'project_map',
+            description: t('indexer.project_map_desc'),
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['summary', 'refresh', 'find'],
+                        description: t('indexer.project_map_action_desc'),
+                    },
+                    query: {
+                        type: 'string',
+                        description: t('indexer.project_map_query_desc'),
+                    },
+                },
+                required: ['action'],
+            },
+            handler: async (_ctx, args) => {
+                const action = String(args.action || 'summary');
+                if (action === 'refresh') {
+                    const result = await this.refresh();
+                    const summary = result ? this.indexer.summarize(result) : t('indexer.empty');
+                    return this.makeResult(t('indexer.refreshed', { summary }));
+                }
+                if (action === 'find') {
+                    const query = String(args.query || '').toLowerCase();
+                    if (!query)
+                        return { success: false, output: t('tool.invalid_params') };
+                    const matches = this.find(query);
+                    if (matches.length === 0) {
+                        return this.makeResult(t('indexer.no_matches', { query }));
+                    }
+                    const lines = matches.map((f) => {
+                        const path = f.path.replace(/\\/g, '/');
+                        const exports = f.exports.length > 0 ? `: ${f.exports.join(', ')}` : '';
+                        return `- ${path}${exports}`;
+                    }).join('\n');
+                    return this.makeResult(t('indexer.find_results', { count: matches.length, results: lines }));
+                }
+                if (!this.index) {
+                    await this.buildIndex();
+                }
+                if (!this.index) {
+                    return this.makeResult(t('indexer.not_indexed'));
+                }
+                const summary = this.indexer.summarize(this.index);
+                return this.makeResult(t('indexer.summary', { summary }));
+            },
+        };
+    }
+    makeResult(output) {
+        return { success: true, output, display: output };
+    }
+}