micro-models-agent 0.41.2 → 0.42.0

package/dist/modules/context/chunk-query.js

@@ -1,100 +0,0 @@
-export const DEFAULT_CHUNK_SYSTEM_PROMPT = 'Answer the query using ONLY the provided text. Be concise. If the text does not contain the answer, say "NO_EVIDENCE".';
-export const DEFAULT_SYNTHESIS_SYSTEM_PROMPT = "You are given a query and per-chunk answers over a large text. Produce the final answer to the query, combining evidence from the chunks. If no chunk had evidence, say so.";
-/** Split text into newline-aware chunks, each <= chunkChars chars. */
-export function splitTextIntoChunks(text, chunkChars) {
-    if (chunkChars <= 0)
-        throw new Error("chunkChars must be > 0");
-    if (text.length <= chunkChars)
-        return [text];
-    const lines = text.split("\n");
-    const chunks = [];
-    let current = [];
-    let size = 0;
-    for (const line of lines) {
-        if (current.length > 0 && size + line.length + 1 > chunkChars) {
-            chunks.push(current.join("\n"));
-            current = [];
-            size = 0;
-        }
-        current.push(line);
-        size += line.length + 1;
-    }
-    if (current.length > 0)
-        chunks.push(current.join("\n"));
-    return chunks;
-}
-async function chatText(provider, messages, maxTokens, reasoningEffort) {
-    let out = "";
-    for await (const chunk of provider.chat(messages, undefined, undefined, {
-        maxTokens,
-        reasoningEffort,
-    })) {
-        if (chunk.type === "text" && chunk.content)
-            out += chunk.content;
-    }
-    return out;
-}
-/**
- * RLM-style llm_query: answer `query` over `text` by chunking and querying the
- * model per chunk with a fixed system prompt (KV-cache friendly), bounded
- * concurrency, and an optional synthesis pass.
- */
-export async function runChunkQuery(provider, text, query, opts = {}) {
-    const chunkChars = opts.chunkChars ?? 12000;
-    const maxParallel = Math.max(1, opts.maxParallel ?? 4);
-    const maxChunkTokens = opts.maxChunkTokens ?? 1024;
-    const maxSynthesisTokens = opts.maxSynthesisTokens ?? 2048;
-    const reasoningEffort = opts.reasoningEffort ?? "none";
-    const chunks = splitTextIntoChunks(text, chunkChars);
-    const answers = new Array(chunks.length);
-    const chunkSystem = opts.querySystemPrompt ?? DEFAULT_CHUNK_SYSTEM_PROMPT;
-    const logger = opts.logger;
-    if (chunks.length === 1) {
-        logger?.debug(`runChunkQuery: single chunk (${text.length} chars), no chunking needed`);
-    }
-    else {
-        logger?.debug(`runChunkQuery: ${chunks.length} chunks over ${text.length} chars (chunkChars=${chunkChars}, maxParallel=${maxParallel})`);
-    }
-    let cursor = 0;
-    let inFlight = 0;
-    let maxParallelObserved = 0;
-    const workers = Array.from({ length: Math.min(maxParallel, chunks.length) }, async () => {
-        while (cursor < chunks.length) {
-            const idx = cursor++;
-            inFlight++;
-            maxParallelObserved = Math.max(maxParallelObserved, inFlight);
-            try {
-                answers[idx] = await chatText(provider, [
-                    { role: "system", content: chunkSystem },
-                    { role: "user", content: `Query: ${query}\n\nText:\n${chunks[idx]}` },
-                ], maxChunkTokens, reasoningEffort);
-            }
-            finally {
-                inFlight--;
-            }
-        }
-    });
-    await Promise.all(workers);
-    let synthesis = "";
-    if (opts.synthesize !== false && chunks.length > 0) {
-        const joined = answers
-            .map((a, i) => `--- Chunk ${i + 1}/${chunks.length} ---\n${a}`)
-            .join("\n\n");
-        logger?.debug(`runChunkQuery: synthesis pass over ${chunks.length} answers`);
-        synthesis = await chatText(provider, [
-            {
-                role: "system",
-                content: opts.synthesisSystemPrompt ?? DEFAULT_SYNTHESIS_SYSTEM_PROMPT,
-            },
-            { role: "user", content: `Query: ${query}\n\nChunk answers:\n${joined}` },
-        ], maxSynthesisTokens, reasoningEffort);
-    }
-    logger?.debug(`runChunkQuery: done, ${chunks.length} chunks, max parallel observed ${maxParallelObserved}, synthesis ${synthesis.length} chars`);
-    return {
-        chunks: chunks.length,
-        answers,
-        synthesis,
-        totalChars: text.length,
-        maxParallelObserved,
-    };
-}

package/dist/modules/context/fact-extractor.js

@@ -1,162 +0,0 @@
-import { getMessageText } from "../../llm/provider";
-/**
- * Regex-based fact extraction from tool/assistant messages. Owns the file /
- * deleted / decision / error fact lists that survive compaction. Extracted
- * from ContextManager so the ~115-line regex logic has one home (rule #2).
- */
-export class FactExtractor {
-    fileFacts = [];
-    deletedFacts = [];
-    decisionFacts = [];
-    errorFacts = [];
-    readFacts = [];
-    static MAX_FACTS = 20;
-    get errorCount() {
-        return this.errorFacts.length;
-    }
-    /** Scan a batch of compacted turns and fold their facts into the lists. */
-    extract(turns) {
-        // Absolute Windows paths ("E:\proj\src\a.ts") need an optional drive prefix;
-        // without it the colon breaks the match and the fact is silently dropped.
-        const DRIVE = "(?:[a-zA-Z]:[\\\\/])?";
-        const createdPatterns = [
-            new RegExp(`(?:Created|Updated|Written|Moved|Replaced in) ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`Файл (?:создан|обновлён|записан|перемещён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`file (?:created|updated|written|moved):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-        ];
-        const deletedPatterns = [
-            new RegExp(`Deleted ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-            new RegExp(`(?:Удалён|Файл удалён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
-        ];
-        // read_file output header — locale-independent prefix `── path (ext, …`
-        // (en: "lines", ru: "строк"). The path is already prefixed with the same
-        // box-drawing marker in both locales, so the pattern needs no localization.
-        const readPatterns = [new RegExp(`── (${DRIVE}[\\w./\\\\-]+\\.[a-z]+) \\(`, "gi")];
-        const newFiles = [];
-        const newDeleted = [];
-        const newDecisions = [];
-        const newErrors = [];
-        const newReads = [];
-        // Track the LAST tool event per path so a delete followed by a re-create
-        // (or vice versa) in the same window resolves to its final state instead of
-        // being both filtered out of [Files:] and reported as [Deleted:].
-        const lastEvent = new Map();
-        for (const msg of turns) {
-            const content = getMessageText(msg.content);
-            // The system prompt is never a fact source — the memory module embeds
-            // errors.md (with historical "Tool X failed Nx" entries from PAST days)
-            // there, and extracting that text as current [Errors:] misleads the model
-            // into thinking IT is failing (observed: ses_msvuao0h — a stale
-            // "edit_file failed 3x" from 2026-08-15 landed in every compaction
-            // summary as if it were the live session's failure).
-            if (msg.role === "system")
-                continue;
-            // Never feed a previous <system-summary> block into new facts — that is
-            // the source of recursive summary nesting (summary inside summary).
-            if (msg.role === "user" &&
-                (content.startsWith("<system-summary>") || content.includes("[Compressed:"))) {
-                continue;
-            }
-            if (msg.role === "tool") {
-                for (const pattern of createdPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newFiles.push(match[1]);
-                        lastEvent.set(match[1], "file");
-                    }
-                }
-                for (const pattern of deletedPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newDeleted.push(match[1]);
-                        lastEvent.set(match[1], "deleted");
-                    }
-                }
-                for (const pattern of readPatterns) {
-                    for (const match of content.matchAll(pattern)) {
-                        newReads.push(match[1]);
-                    }
-                }
-                if (content.includes("Plan:") && content.includes("[")) {
-                    const planLine = content.split("\n").find((line) => line.includes("Plan:"));
-                    if (planLine)
-                        newDecisions.push(planLine.trim());
-                }
-            }
-            if (msg.role === "assistant") {
-                if (content.includes("decided:") || content.includes("decision:")) {
-                    const line = content
-                        .split("\n")
-                        .find((l) => l.includes("decided:") || l.includes("decision:"));
-                    if (line)
-                        newDecisions.push(line.trim().slice(0, 200));
-                }
-            }
-            if (msg.role === "tool" || msg.role === "assistant") {
-                if (content.includes("Error:") ||
-                    content.includes("failed") ||
-                    content.includes("Ошибка:") ||
-                    content.includes("не удалось")) {
-                    const line = content
-                        .split("\n")
-                        .find((l) => l.includes("Error:") ||
-                        l.includes("failed") ||
-                        l.includes("Ошибка:") ||
-                        l.includes("не удалось"));
-                    if (line)
-                        newErrors.push(line.trim().slice(0, 250));
-                }
-            }
-        }
-        // Deduplicate and cap facts to prevent unbounded growth. Files that were
-        // DELETED leave the "known files" list — a deleted file must not keep
-        // being reported as existing (observed: deleted .js files listed in
-        // every [Files: ...] block for the whole session). A path that is deleted
-        // then RE-CREATED (delete_file A → write_file A) is un-deleted: the last
-        // event in the window wins, so it returns to [Files:] and leaves [Deleted:].
-        const dedup = (arr) => [...new Set(arr)];
-        const finalFiles = dedup(newFiles.filter((p) => lastEvent.get(p) === "file"));
-        const finalDeleted = dedup(newDeleted.filter((p) => lastEvent.get(p) === "deleted"));
-        this.fileFacts = dedup([...this.fileFacts, ...finalFiles].filter((p) => !finalDeleted.includes(p))).slice(-FactExtractor.MAX_FACTS);
-        this.deletedFacts = dedup([...this.deletedFacts, ...finalDeleted].filter((p) => !finalFiles.includes(p))).slice(-FactExtractor.MAX_FACTS);
-        this.decisionFacts = dedup([...this.decisionFacts, ...newDecisions]).slice(-FactExtractor.MAX_FACTS);
-        this.errorFacts = dedup([...this.errorFacts, ...newErrors]).slice(-FactExtractor.MAX_FACTS);
-        this.readFacts = dedup([...this.readFacts, ...newReads]).slice(-FactExtractor.MAX_FACTS);
-    }
-    /** `[Files: a; b]` line for a compaction summary, or null. */
-    filesLine() {
-        const deletedSet = new Set(this.deletedFacts);
-        const liveFiles = this.fileFacts.filter((p) => !deletedSet.has(p));
-        if (liveFiles.length === 0)
-            return null;
-        return `[Files: ${liveFiles.slice(-15).join("; ")}]`;
-    }
-    /** `[Deleted: c]` line, or null. */
-    deletedLine() {
-        if (this.deletedFacts.length === 0)
-            return null;
-        return `[Deleted: ${this.deletedFacts.slice(-10).join("; ")}]`;
-    }
-    /** `[Decisions: d]` line, or null. */
-    decisionsLine() {
-        if (this.decisionFacts.length === 0)
-            return null;
-        return `[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`;
-    }
-    /** `[Errors: e]` line, or null. */
-    errorsLine() {
-        if (this.errorFacts.length === 0)
-            return null;
-        return `[Errors: ${this.errorFacts.slice(-3).join("; ")}]`;
-    }
-    /**
-     * `[Read: p1; p2]` line — files already inspected via read_file. Lets the
-     * model re-orient after compaction without rescanning the whole project: it
-     * knows which files were already read and only re-reads what changed
-     * (observed: post-compaction the model re-read the same files it had already
-     * inspected, because "already read" never survived compaction).
-     */
-    readLine() {
-        if (this.readFacts.length === 0)
-            return null;
-        return `[Read: ${this.readFacts.slice(-12).join("; ")}]`;
-    }
-}

package/dist/modules/context/history.js

@@ -1,15 +0,0 @@
-import { appendFileSync, mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
-export class SessionHistoryWriter {
-    historyPath;
-    constructor(sessionsDir, sessionId) {
-        const sessionDir = join(sessionsDir, sessionId);
-        if (!existsSync(sessionDir)) {
-            mkdirSync(sessionDir, { recursive: true });
-        }
-        this.historyPath = join(sessionDir, 'history.jsonl');
-    }
-    append(msg) {
-        appendFileSync(this.historyPath, JSON.stringify(msg) + '\n', 'utf-8');
-    }
-}

package/dist/modules/execution/audit-runners.js

@@ -1,152 +0,0 @@
-import { existsSync, readdirSync } from "fs";
-import { dirname, join, resolve } from "path";
-import { detectTestResults } from "../../tools/bash";
-import { processRegistry } from "../processes";
-/** Directories never searched for test files. */
-export const SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    ".mma",
-    "dist",
-    "build",
-    "coverage",
-    ".next",
-    ".nuxt",
-    "vendor",
-]);
-const TEST_EXT_RE = /\.(test|spec)\.[jt]sx?$/i;
-const TEST_STEP_RE = /\b(test(ing|s)?|тест(ы|ирование|ировать)?|провер\w*\s+тест|запустить\s+тест)\b|bun test|npm test|vitest|pytest|go test|jest|mocha/i;
-/** Recursive, depth-limited walk that stops early on the first test file. */
-export function findTestFile(dir, depth = 0) {
-    if (depth > 5)
-        return null;
-    let entries;
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return null;
-    }
-    for (const e of entries) {
-        const full = join(dir, e.name);
-        if (e.isDirectory()) {
-            if (SKIP_DIRS.has(e.name))
-                continue;
-            const found = findTestFile(full, depth + 1);
-            if (found)
-                return found;
-        }
-        else if (TEST_EXT_RE.test(e.name)) {
-            return full;
-        }
-    }
-    return null;
-}
-/** The plan's step descriptions mention running/checking tests. */
-export function hasTestStep(plan) {
-    return plan.steps.some((s) => TEST_STEP_RE.test(s.description));
-}
-/** Extract failing test names from a runner's output (bun/vitest style). */
-function extractFailingNames(output, limit = 5) {
-    const names = [];
-    for (const m of output.matchAll(/\(fail\)\s*([^\n]+)/g)) {
-        const name = m[1].trim();
-        if (name && !names.includes(name))
-            names.push(name);
-        if (names.length >= limit)
-            break;
-    }
-    return names;
-}
-export async function runTests(baseDir) {
-    const entry = processRegistry.start("bun test", baseDir);
-    const exited = await processRegistry.waitForExit(entry.id, 90_000);
-    const output = entry.log.join("\n");
-    processRegistry.remove(entry.id);
-    if (!exited) {
-        // Timed out — we cannot claim success or failure from an unfinished run.
-        return {
-            checked: true,
-            passed: true, // don't block completion on an inconclusive run
-            failed: 0,
-            passedCount: 0,
-            detail: "test run timed out after 90s — result unknown",
-            command: "bun test",
-        };
-    }
-    const run = detectTestResults(output);
-    if (!run) {
-        // No recognizable runner summary. A non-zero exit means the test run
-        // (or its runner) failed — the audit must not pass on it; report a
-        // single "at least one failed" since we cannot count them. Exit 0
-        // with unrecognized output stays checked-but-inconclusive.
-        return {
-            checked: true,
-            passed: entry.exitCode === 0,
-            failed: entry.exitCode === 0 ? 0 : 1,
-            passedCount: 0,
-            detail: output.slice(0, 200).trim(),
-            command: "bun test",
-        };
-    }
-    const names = extractFailingNames(output);
-    return {
-        checked: true,
-        passed: run.failed === 0,
-        failed: run.failed,
-        passedCount: run.passed,
-        detail: names.length
-            ? names.join("; ")
-            : run.summary || `${run.failed} failed / ${run.passed} passed`,
-        command: "bun test",
-    };
-}
-/** First `error TS…` line in a tsc output, or null when none/inconclusive. */
-export function parseTypecheckErrors(output) {
-    const line = output.split("\n").find((l) => /error TS\d+/.test(l));
-    return line ? line.trim().slice(0, 300) : null;
-}
-/**
- * Locate the nearest project root that owns a tsconfig.json.
- *
- * The agent frequently creates the project in a nested subfolder of its
- * baseDir (e.g. `bicycle-shop/`), so the tsconfig lives at
- * `baseDir/bicycle-shop/` and the old `existsSync(baseDir/tsconfig.json)`
- * gate silently skipped the final typecheck — the audit passed even with
- * dozens of tsc errors (observed in both analyzed sessions). This walks each
- * candidate (baseDir plus the resolved step files) upward to the nearest
- * tsconfig.json, preferring the shallowest hit so the baseDir project wins
- * over a stray tsconfig further up. Returns null when no tsconfig exists in
- * any reachable subtree. `existingFiles` must contain resolved absolute paths
- * (relative tokens would resolve against the process cwd, not baseDir).
- */
-export function findTypecheckRoot(baseDir, existingFiles = []) {
-    const candidates = [baseDir, ...existingFiles];
-    let best = null;
-    for (const start of candidates) {
-        let dir = resolve(start);
-        for (let depth = 0; depth <= 10; depth++) {
-            if (existsSync(join(dir, "tsconfig.json"))) {
-                if (!best || depth < best.depth)
-                    best = { depth, root: dir };
-                break;
-            }
-            const parent = dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
-    }
-    return best?.root ?? null;
-}
-export async function runTypecheck(baseDir) {
-    const entry = processRegistry.start("npx --no-install tsc --noEmit --skipLibCheck", baseDir);
-    const exited = await processRegistry.waitForExit(entry.id, 90_000);
-    const output = entry.log.join("\n");
-    processRegistry.remove(entry.id);
-    // A timeout, or output with no `error TS` lines (missing typescript / wrong
-    // working dir) is inconclusive — never block completion on those.
-    if (!exited)
-        return null;
-    return parseTypecheckErrors(output);
-}