micro-models-agent 0.60.1 → 0.61.1

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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,168 @@
+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("; ")}]`;
+    }
+    /** All known live files (not deleted) — used to seed the hallucination
+     *  checker's known-files set after compaction. */
+    getKnownFiles() {
+        const deletedSet = new Set(this.deletedFacts);
+        return this.fileFacts.filter((p) => !deletedSet.has(p));
+    }
+    /** `[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

@@ -0,0 +1,15 @@
+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/context/index.js

@@ -0,0 +1 @@
+export { ContextManager } from "./manager";