micro-models-agent 0.63.0 → 1.1.0

package/dist/modules/session/store.js

@@ -57,7 +57,10 @@ export class SessionStore {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         const content = JSON.stringify(meta, null, 2);
         if (this.encryptor) {
-            writeFileSync(this.metaPath(id), this.encryptor.encryptFileContent(content), { encoding: "utf-8", mode: 0o600 });
+            writeFileSync(this.metaPath(id), this.encryptor.encryptFileContent(content), {
+                encoding: "utf-8",
+                mode: 0o600,
+            });
         }
         else {
             writeFileSync(this.metaPath(id), content, { encoding: "utf-8", mode: 0o600 });
@@ -81,17 +84,39 @@ export class SessionStore {
             return null;
         }
     }
+    /** Read meta straight from disk, bypassing _metaCache — used where counter
+     *  accuracy matters more than read speed (see appendMessage). */
+    readMetaFromDisk(id) {
+        const path = this.metaPath(id);
+        if (!existsSync(path))
+            return null;
+        try {
+            const raw = readFileSync(path, "utf-8");
+            const content = this.encryptor ? this.encryptor.decryptFileContent(raw) : raw;
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
     appendMessage(id, msg) {
         const dir = this.sessionDir(id);
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         const line = JSON.stringify(msg);
         if (this.encryptor?.isEnabled()) {
-            appendFileSync(this.historyPath(id), this.encryptor.encryptFileContent(line) + "\n", { encoding: "utf-8", mode: 0o600 });
+            appendFileSync(this.historyPath(id), this.encryptor.encryptFileContent(line) + "\n", {
+                encoding: "utf-8",
+                mode: 0o600,
+            });
         }
         else {
             appendFileSync(this.historyPath(id), line + "\n", { encoding: "utf-8", mode: 0o600 });
         }
-        const meta = this.loadMeta(id);
+        // Re-read meta from disk (not the cache) right before the increment so
+        // counters appended by ANOTHER process are not clobbered by a stale
+        // in-memory snapshot (last-write-wins). Full cross-process locking is out
+        // of scope; this narrows the race window.
+        const meta = this.readMetaFromDisk(id) ?? this._metaCache.get(id) ?? null;
         if (meta) {
             meta.messageCount = (meta.messageCount || 0) + 1;
             meta.updatedAt = msg.timestamp || new Date().toISOString();
@@ -138,7 +163,10 @@ export class SessionStore {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         const line = JSON.stringify(entry);
         if (this.encryptor?.isEnabled()) {
-            appendFileSync(this.sessionLogPath(id), this.encryptor.encryptFileContent(line) + "\n", { encoding: "utf-8", mode: 0o600 });
+            appendFileSync(this.sessionLogPath(id), this.encryptor.encryptFileContent(line) + "\n", {
+                encoding: "utf-8",
+                mode: 0o600,
+            });
         }
         else {
             appendFileSync(this.sessionLogPath(id), line + "\n", { encoding: "utf-8", mode: 0o600 });
@@ -204,7 +232,7 @@ export class SessionStore {
     rotateOldSessions() {
         const thirtyDaysAgo = new Date();
         thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
-        const sessions = this.listSessions();
+        const sessions = this.listSessions().slice();
         for (const session of sessions) {
             const updatedAt = new Date(session.updatedAt);
             if (updatedAt < thirtyDaysAgo) {
@@ -215,6 +243,14 @@ export class SessionStore {
                     const gzPath = join(this.baseDir, `${session.id}.jsonl.gz`);
                     writeFileSync(gzPath, compressed);
                     rmSync(historyPath);
+                    // Mark the meta so the session stops looking "live" in lists —
+                    // otherwise a gzipped session still advertises messageCount > 0.
+                    const meta = this.loadMeta(session.id);
+                    if (meta) {
+                        meta.messageCount = 0;
+                        meta.rotated = true;
+                        this.saveMeta(session.id, meta);
+                    }
                 }
             }
         }

package/dist/modules/skills/loader.js

@@ -12,7 +12,13 @@ export class SkillsLoader {
         const entries = readdirSync(dirPath);
         for (const entry of entries) {
             const fullPath = join(dirPath, entry);
-            const stat = statSync(fullPath);
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
             if (stat.isDirectory()) {
                 this.scanDir(fullPath, skills);
                 continue;

package/dist/modules/skills/module.js

@@ -1,4 +1,5 @@
 import { t } from "../../i18n/index";
+import { estimateTokens } from "../../llm/token-counter";
 export class SkillsModule {
     name = "skills";
     availableSkills;
@@ -124,6 +125,6 @@ export class SkillsModule {
         };
     }
     estimateTokens(text) {
-        return Math.ceil(text.length / 4);
+        return estimateTokens(text);
     }
 }

package/dist/modules/updater/changelog-reader.js

@@ -0,0 +1,94 @@
+import { readFileSync, existsSync } from "fs";
+import { dirname, join } from "path";
+/**
+ * Read the bundled CHANGELOG.md from the installed npm package.
+ * Resolves relative to this file's location (dist/modules/updater/) going up
+ * to the package root.
+ */
+export function readChangelog(packageName) {
+    try {
+        // Walk up from this file to find package.json
+        let dir = dirname(import.meta.url);
+        // Convert file:// URL to path on POSIX, or just use the path directly
+        if (dir.startsWith("file://")) {
+            dir = decodeURIComponent(dir.slice(7));
+        }
+        // Find package root (contains package.json with matching name)
+        for (let i = 0; i < 10; i++) {
+            const pkgPath = join(dir, "package.json");
+            if (existsSync(pkgPath)) {
+                const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+                if (pkg.name === packageName) {
+                    const changelogPath = join(dir, "CHANGELOG.md");
+                    if (existsSync(changelogPath)) {
+                        return readFileSync(changelogPath, "utf-8");
+                    }
+                    return null;
+                }
+            }
+            dir = dirname(dir);
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extract changelog entries between two versions (exclusive old, inclusive new).
+ * Returns the raw markdown sections.
+ *
+ * parseChangelog(changelog, "0.55.1", "0.56.1") =>
+ *   "## [0.56.1] - ...\n...\n## [0.56.0] - ...\n..."
+ */
+export function extractChangelogRange(changelog, fromVersion, toVersion) {
+    const lines = changelog.split("\n");
+    const sections = [];
+    let capturing = false;
+    let foundFrom = false;
+    for (const line of lines) {
+        const match = line.match(/^## \[(\d+\.\d+\.\d+)\]/);
+        if (match) {
+            const ver = match[1];
+            if (ver === fromVersion) {
+                // Stop before this section (exclusive).
+                foundFrom = true;
+                break;
+            }
+            if (capturing) {
+                // New section header — separate with blank line.
+                sections.push("");
+            }
+            capturing = true;
+        }
+        if (capturing) {
+            sections.push(line);
+        }
+    }
+    // If the "from" version was never found, return null (no valid range).
+    if (!foundFrom)
+        return null;
+    return sections.length > 0 ? sections.join("\n").trim() : null;
+}
+/**
+ * Get the latest changelog entry (most recent version).
+ */
+export function extractLatestChangelog(changelog) {
+    const lines = changelog.split("\n");
+    const sections = [];
+    let capturing = false;
+    let found = false;
+    for (const line of lines) {
+        const match = line.match(/^## \[(\d+\.\d+\.\d+)\]/);
+        if (match) {
+            if (found)
+                break; // Stop at second section header.
+            capturing = true;
+            found = true;
+        }
+        if (capturing) {
+            sections.push(line);
+        }
+    }
+    return sections.length > 0 ? sections.join("\n").trim() : null;
+}

package/dist/modules/updater/dev-detect.js

@@ -0,0 +1,17 @@
+/**
+ * True when the running entry is a TypeScript source file — i.e. a dev run
+ * (`bun run src/cli/main.ts`, `bun --watch src/cli/main.ts`, tsx/ts-node).
+ * The published package is loaded as bundled `dist/main.js` via `bin/mma.mjs`,
+ * so this is false for real installs.
+ *
+ * Dev runs MUST NOT self-update: a checkout's package.json version can
+ * legitimately trail npm, and silently `npm install -g`-ing over the user's
+ * global install from a dev working tree is destructive and surprising.
+ */
+export function isDevEntryPath(path) {
+    const clean = path.split(/[?#]/)[0];
+    return (clean.endsWith(".ts") ||
+        clean.endsWith(".tsx") ||
+        clean.endsWith(".mts") ||
+        clean.endsWith(".cts"));
+}

package/dist/modules/updater/index.js

@@ -1,2 +1,3 @@
 export { Updater } from "./checker";
 export { UpdaterModule } from "./module";
+export { isDevEntryPath } from "./dev-detect";

package/dist/modules/updater/module.js

@@ -1,6 +1,8 @@
 import { Updater } from "./checker";
+import { extractLatestChangelog, readChangelog } from "./changelog-reader";
 import { t } from "../../i18n/index";
 import { pc } from "../../ui/colors";
+import { defaultOutputBus } from "../../output";
 /**
  * Self-update module. Fires an ASYNC (non-blocking) check at startup so the
  * agent never waits on the network. When `autoInstall` is enabled, a newer
@@ -24,8 +26,8 @@ export class UpdaterModule {
         this.updater = new Updater(currentVersion, packageName, installRunner);
         this.logger = logger ?? {
             info: () => { },
-            warn: (m) => console.warn(pc.yellow(m)),
-            error: (m) => console.error(pc.red(m)),
+            warn: (m) => defaultOutputBus.log("warn", "updater", m),
+            error: (m) => defaultOutputBus.log("error", "updater", m),
         };
     }
     /** Test hook: prevent the module from actually running npm install. */
@@ -96,7 +98,16 @@ export class UpdaterModule {
             }));
             const install = await this.updater.install(result.latest);
             if (install.success) {
-                this.logger.info(t("updater.installed", { current: result.current, latest: result.latest }));
+                const changelog = readChangelog("micro-models-agent");
+                const latestEntry = changelog ? extractLatestChangelog(changelog) : null;
+                const changelogBlock = latestEntry
+                    ? pc.cyan(`\n${t("cli.changelog_title", { version: result.latest })}\n`) + latestEntry
+                    : "";
+                this.logger.info(t("updater.installed", {
+                    current: result.current,
+                    latest: result.latest,
+                    changelog: changelogBlock,
+                }));
             }
             else {
                 this.logger.warn(t("updater.install_failed", {

package/dist/output/bus.js

@@ -0,0 +1,32 @@
+export class OutputBus {
+    seq = 0;
+    subs = new Set();
+    subscribe(fn) {
+        this.subs.add(fn);
+        return () => this.subs.delete(fn);
+    }
+    emit(ev) {
+        const full = { ...ev, id: ++this.seq, ts: Date.now() };
+        for (const fn of [...this.subs]) {
+            try {
+                fn(full);
+            }
+            catch {
+                /* a subscriber must not break the bus */
+            }
+        }
+        return full;
+    }
+    log(level, source, text, data) {
+        return this.emit({ level, source, kind: "log", text, data });
+    }
+    /**
+     * Test-isolation / rare-use hook: drops all subscribers and restarts the id sequence.
+     * Do not call this in production code paths.
+     */
+    reset() {
+        this.subs.clear();
+        this.seq = 0;
+    }
+}
+export const defaultOutputBus = new OutputBus();

package/dist/output/channel.js

@@ -0,0 +1,233 @@
+import { defaultOutputBus } from "./bus";
+import { formatEventLine } from "./format";
+export class OutputChannel {
+    bus;
+    out;
+    err;
+    color;
+    mode = "idle";
+    modeBeforeQuiet = "idle";
+    modeBeforeModal = "idle";
+    modalDepth = 0;
+    sink = null;
+    queue = [];
+    pending = null;
+    partialOpen = false;
+    /**
+     * Log/block stdout events captured while a prompt is active. They are
+     * flushed once per microtask so a synchronous burst (e.g. a 20-line command
+     * result) produces a single `printAbove` + one frame render instead of one
+     * per line (which erased/redrew the frame and fired a DSR query each time).
+     */
+    blockLines = null;
+    blockFlushScheduled = false;
+    unsub;
+    constructor(bus = defaultOutputBus, opts = {}) {
+        this.bus = bus;
+        this.out = opts.out ?? process.stdout;
+        this.err = opts.err ?? process.stderr;
+        const outTTY = this.out.isTTY === true;
+        this.color = opts.color ?? (!process.env.NO_COLOR && !process.env.CI && outTTY);
+        this.unsub = this.bus.subscribe((ev) => this.onEvent(ev));
+    }
+    dispose() {
+        this.flushBlocks();
+        this.unsub();
+        this.queue = [];
+        this.pending = null;
+        this.partialOpen = false;
+        this.sink = null;
+        this.mode = "idle";
+    }
+    attachPrompt(sink) {
+        this.sink = sink;
+    }
+    getMode() {
+        return this.mode;
+    }
+    beginStreaming() {
+        // A streaming transition must never discard the quiet state: `--json`
+        // sets quiet for the whole run and streamed runs must stay silent.
+        if (this.mode === "quiet")
+            return;
+        this.flushBlocks();
+        this.flushPendingAsBlock();
+        this.mode = "streaming";
+    }
+    endStreaming() {
+        // Symmetric with beginStreaming: quiet owns the mode until setQuiet(false).
+        if (this.mode === "quiet")
+            return;
+        this.closePartial();
+        this.mode = "idle";
+    }
+    beginModal() {
+        this.flushBlocks();
+        this.flushPendingAsBlock();
+        if (this.mode === "quiet")
+            return; // setQuiet owns quiet
+        // Nested modals (e.g. a wizard command inside another exclusive scope)
+        // must not overwrite the mode saved by the outermost beginModal.
+        if (this.modalDepth === 0)
+            this.modeBeforeModal = this.mode;
+        this.modalDepth++;
+        this.mode = "modal";
+    }
+    endModal() {
+        if (this.modalDepth > 0)
+            this.modalDepth--;
+        if (this.mode === "modal" && this.modalDepth === 0)
+            this.mode = this.modeBeforeModal;
+        const q = this.queue;
+        this.queue = [];
+        for (const ev of q)
+            this.onEvent(ev);
+    }
+    setQuiet(quiet) {
+        this.flushBlocks();
+        if (quiet) {
+            if (this.mode !== "quiet") {
+                this.modeBeforeQuiet = this.mode;
+                this.mode = "quiet";
+            }
+        }
+        else if (this.mode === "quiet") {
+            this.mode = this.modeBeforeQuiet;
+        }
+    }
+    writeRaw(text, stream = "stdout") {
+        // Raw output must never jump ahead of queued block lines.
+        this.flushBlocks();
+        // modal intentionally drops direct writes: the Renderer never runs during a modal prompt.
+        if (this.mode === "modal" || this.mode === "quiet")
+            return;
+        if (this.mode === "idle" && this.sink?.isActive() && stream === "stdout") {
+            const prev = this.pending?.stream === "stdout" ? this.pending.text : "";
+            this.pending = { stream, text: prev + text };
+            this.drainPending();
+            return;
+        }
+        if (stream === "stdout")
+            this.partialOpen = !text.endsWith("\n");
+        (stream === "stderr" ? this.err : this.out).write(text);
+    }
+    writeLine(text, stream = "stdout") {
+        this.bus.emit({ level: "info", source: "", kind: "block", text, stream });
+    }
+    clearScreen() {
+        this.flushBlocks();
+        // A buffered raw partial line would otherwise re-appear after the clear.
+        this.flushPendingAsBlock();
+        this.partialOpen = false;
+        if (this.mode === "quiet")
+            return;
+        if (this.sink?.isActive() && this.sink.clearScreen) {
+            this.sink.clearScreen();
+            return;
+        }
+        this.out.write("\x1b[2J\x1b[H");
+    }
+    writeOverlay(text) {
+        // modal intentionally drops overlays: the Renderer never runs during a modal prompt.
+        // Task 6's Spinner must stop before any log so an overlay never shares a row with a log line.
+        if (this.mode === "modal" || this.mode === "quiet")
+            return;
+        if (this.mode === "idle" && this.sink?.isActive())
+            return;
+        this.err.write(text);
+    }
+    onEvent(ev) {
+        if (this.mode === "quiet")
+            return;
+        if (this.mode === "modal") {
+            this.queue.push(ev);
+            return;
+        }
+        if (ev.kind === "raw") {
+            this.writeRaw(ev.text, ev.stream);
+            return;
+        }
+        const stream = ev.stream ?? "stdout";
+        const line = ev.kind === "block" ? ev.text : formatEventLine(ev, this.color);
+        if (this.mode === "idle" && this.sink?.isActive()) {
+            // Batch a synchronous burst into one printAbove/render (see blockLines).
+            // Both streams route above the prompt, otherwise a stderr log writes
+            // directly over the active input frame and skips flushBlocks ordering.
+            if (this.blockLines === null)
+                this.blockLines = [];
+            this.blockLines.push(line);
+            if (!this.blockFlushScheduled) {
+                this.blockFlushScheduled = true;
+                queueMicrotask(() => this.flushBlocks());
+            }
+            return;
+        }
+        // Preserve FIFO ordering: buffered blocks must not be overtaken by an
+        // event written straight to a raw stream (e.g. a stderr log mid-stream).
+        this.flushBlocks();
+        if (this.mode === "streaming")
+            this.closePartial();
+        (stream === "stderr" ? this.err : this.out).write(`${line}\n`);
+    }
+    flushBlocks() {
+        this.blockFlushScheduled = false;
+        const lines = this.blockLines;
+        this.blockLines = null;
+        if (!lines || lines.length === 0)
+            return;
+        const text = lines.join("\n");
+        if (this.sink?.isActive()) {
+            this.sink.printAbove(text);
+        }
+        else {
+            this.out.write(`${text}\n`);
+        }
+    }
+    closePartial() {
+        if (this.partialOpen) {
+            this.out.write("\n");
+            this.partialOpen = false;
+        }
+    }
+    drainPending() {
+        if (!this.pending)
+            return;
+        const { stream, text } = this.pending;
+        const idx = text.lastIndexOf("\n");
+        if (idx < 0)
+            return;
+        const head = text.slice(0, idx + 1);
+        this.pending = { stream, text: text.slice(idx + 1) };
+        const lines = head.replace(/\n$/, "").split("\n");
+        if (this.sink?.isActive())
+            this.sink.printAbove(lines.join("\n"));
+        else
+            this.out.write(head);
+    }
+    flushPendingAsBlock() {
+        this.flushBlocks();
+        if (!this.pending)
+            return;
+        const text = this.pending.text;
+        const { stream } = this.pending;
+        this.pending = null;
+        if (this.sink?.isActive()) {
+            this.sink.printAbove(text);
+            this.partialOpen = false;
+        }
+        else {
+            (stream === "stderr" ? this.err : this.out).write(text);
+            this.partialOpen = stream === "stdout" ? !text.endsWith("\n") : this.partialOpen;
+        }
+    }
+}
+let defaultChannel = null;
+export function getDefaultChannel() {
+    if (!defaultChannel)
+        defaultChannel = new OutputChannel(defaultOutputBus);
+    return defaultChannel;
+}
+export function resetDefaultChannel() {
+    defaultChannel?.dispose();
+    defaultChannel = null;
+}

package/dist/output/format.js

@@ -0,0 +1,14 @@
+import { createColors } from "picocolors";
+const colored = createColors(true);
+const LEVEL_COLORS = {
+    debug: (s) => colored.dim(s),
+    info: (s) => s,
+    warn: (s) => colored.yellow(s),
+    error: (s) => colored.red(s),
+};
+/** Reproduces the legacy Logger format: `[LEVEL] [source] ISO — text`. */
+export function formatEventLine(ev, color) {
+    const prefix = ev.source ? ` [${ev.source}]` : "";
+    const line = `[${ev.level.toUpperCase()}]${prefix} ${new Date(ev.ts).toISOString()} — ${ev.text}`;
+    return color ? LEVEL_COLORS[ev.level](line) : line;
+}

package/dist/output/index.js

@@ -0,0 +1,7 @@
+export * from "./types";
+export { OutputBus, defaultOutputBus } from "./bus";
+export { formatEventLine } from "./format";
+export { JsonOutputSink } from "./json-sink";
+export { SessionOutputSink } from "./session-sink";
+export { OutputChannel, getDefaultChannel, resetDefaultChannel, } from "./channel";
+export { writeMachineJson, writeNonTtyLine } from "./machine";

package/dist/output/json-sink.js

@@ -0,0 +1,22 @@
+/**
+ * Collects bus events so a machine-readable run (`--json`) can include the
+ * warn/error diagnostics that the human channel suppresses via `setQuiet`.
+ * Info/debug events are ignored: they are progress noise, not diagnostics.
+ */
+export class JsonOutputSink {
+    events = [];
+    unsub;
+    constructor(bus) {
+        this.unsub = bus.subscribe((ev) => {
+            this.events.push(ev);
+        });
+    }
+    diagnostics() {
+        return this.events
+            .filter((e) => e.level === "warn" || e.level === "error")
+            .map((e) => ({ level: e.level, source: e.source, text: e.text }));
+    }
+    dispose() {
+        this.unsub();
+    }
+}

package/dist/output/machine.js

@@ -0,0 +1,8 @@
+/** Machine-readable output (CLI JSON contracts). The only place with raw stdout. */
+export function writeMachineJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+/** Raw stdout write for the non-TTY REPL fallback (documented single-writer exception). */
+export function writeNonTtyLine(text) {
+    process.stdout.write(text + "\n");
+}

package/dist/output/session-sink.js

@@ -0,0 +1,27 @@
+/**
+ * Persists explicitly marked output events (`data.persist === true`) into the
+ * session log. Most output is transient terminal progress and is deliberately
+ * NOT persisted; the primary file path for durable records stays
+ * `SessionLogger.logSilent` / `logStructured`.
+ */
+export class SessionOutputSink {
+    session;
+    unsub;
+    constructor(bus, session) {
+        this.session = session;
+        this.unsub = bus.subscribe((ev) => {
+            if (ev.data?.persist !== true)
+                return;
+            this.session.appendLog({
+                ts: new Date(ev.ts).toISOString(),
+                type: "output",
+                level: ev.level,
+                source: ev.source,
+                content: ev.text,
+            });
+        });
+    }
+    dispose() {
+        this.unsub();
+    }
+}

package/dist/output/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/approve.js

@@ -21,10 +21,14 @@ export const approveTool = {
             return { success: false, output: t("tool.interactive_disabled") };
         }
         const action = String(args.action || "");
-        const indexes = await askChoice(t("tool.approve_prompt", { action }), [
+        const question = t("tool.approve_prompt", { action });
+        const options = [
             { label: t("tool.approve_yes"), description: t("tool.approve_yes_desc") },
             { label: t("tool.approve_no"), description: t("tool.approve_no_desc") },
-        ]);
+        ];
+        const indexes = ctx.promptIO
+            ? await ctx.promptIO.askChoice(question, options, { allowCustom: false })
+            : await askChoice(question, options);
         if (indexes[0] === 0) {
             return { success: true, output: t("tool.approved") };
         }