micro-models-agent 0.55.0 → 0.55.1

package/dist/modules/session/store.js

@@ -1,222 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, appendFileSync, } from "fs";
-import { join } from "path";
-import { gzipSync } from "zlib";
-import { SessionFileEncryptor } from "../security/session-encryption";
-export class SessionStore {
-    baseDir;
-    encryptor = null;
-    // In-memory meta cache to avoid O(N²) disk reads on appendMessage.
-    _metaCache = new Map();
-    constructor(baseDir, encryptionConfig) {
-        this.baseDir = baseDir;
-        if (encryptionConfig?.enabled) {
-            this.encryptor = new SessionFileEncryptor(encryptionConfig);
-        }
-    }
-    getSessionDir(id) {
-        return join(this.baseDir, id);
-    }
-    /**
-     * Update encryption configuration
-     */
-    updateEncryption(config) {
-        if (config?.enabled) {
-            this.encryptor = new SessionFileEncryptor(config);
-        }
-        else {
-            this.encryptor = null;
-        }
-    }
-    /**
-     * Check if encryption is enabled
-     */
-    isEncryptionEnabled() {
-        return this.encryptor?.isEnabled() ?? false;
-    }
-    init() {
-        mkdirSync(this.baseDir, { recursive: true, mode: 0o700 });
-    }
-    sessionDir(id) {
-        return join(this.baseDir, id);
-    }
-    metaPath(id) {
-        return join(this.sessionDir(id), "meta.json");
-    }
-    historyPath(id) {
-        return join(this.sessionDir(id), "history.jsonl");
-    }
-    sessionLogPath(id) {
-        return join(this.sessionDir(id), "session.jsonl");
-    }
-    sessionExists(id) {
-        return existsSync(this.metaPath(id));
-    }
-    saveMeta(id, meta) {
-        this._metaCache.set(id, meta);
-        const dir = this.sessionDir(id);
-        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 });
-        }
-        else {
-            writeFileSync(this.metaPath(id), content, { encoding: "utf-8", mode: 0o600 });
-        }
-    }
-    loadMeta(id) {
-        const cached = this._metaCache.get(id);
-        if (cached)
-            return cached;
-        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;
-            const meta = JSON.parse(content);
-            this._metaCache.set(id, meta);
-            return meta;
-        }
-        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 });
-        }
-        else {
-            appendFileSync(this.historyPath(id), line + "\n", { encoding: "utf-8", mode: 0o600 });
-        }
-        const meta = this.loadMeta(id);
-        if (meta) {
-            meta.messageCount = (meta.messageCount || 0) + 1;
-            meta.updatedAt = msg.timestamp || new Date().toISOString();
-            this.saveMeta(id, meta);
-        }
-    }
-    loadHistory(id) {
-        const path = this.historyPath(id);
-        if (!existsSync(path))
-            return [];
-        try {
-            const raw = readFileSync(path, "utf-8");
-            const lines = raw.split("\n").filter(Boolean);
-            const parseLine = (line) => {
-                try {
-                    return JSON.parse(line);
-                }
-                catch {
-                    return null;
-                }
-            };
-            if (this.encryptor?.isEnabled()) {
-                return lines
-                    .map((line) => {
-                    try {
-                        return this.encryptor.decryptFileContent(line);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter((l) => l !== null)
-                    .map(parseLine)
-                    .filter((m) => m !== null);
-            }
-            return lines.map(parseLine).filter((m) => m !== null);
-        }
-        catch {
-            return [];
-        }
-    }
-    appendSessionLog(id, entry) {
-        const dir = this.sessionDir(id);
-        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 });
-        }
-        else {
-            appendFileSync(this.sessionLogPath(id), line + "\n", { encoding: "utf-8", mode: 0o600 });
-        }
-    }
-    loadSessionLog(id) {
-        const path = this.sessionLogPath(id);
-        if (!existsSync(path))
-            return [];
-        try {
-            const raw = readFileSync(path, "utf-8");
-            const lines = raw.split("\n").filter(Boolean);
-            const parseLine = (line) => {
-                try {
-                    return JSON.parse(line);
-                }
-                catch {
-                    return null;
-                }
-            };
-            if (this.encryptor?.isEnabled()) {
-                return lines
-                    .map((line) => {
-                    try {
-                        return this.encryptor.decryptFileContent(line);
-                    }
-                    catch {
-                        return null;
-                    }
-                })
-                    .filter((l) => l !== null)
-                    .map(parseLine)
-                    .filter((e) => e !== null);
-            }
-            return lines.map(parseLine).filter((e) => e !== null);
-        }
-        catch {
-            return [];
-        }
-    }
-    listSessions() {
-        if (!existsSync(this.baseDir))
-            return [];
-        const entries = readdirSync(this.baseDir, { withFileTypes: true });
-        const sessions = [];
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const meta = this.loadMeta(entry.name);
-                if (meta)
-                    sessions.push(meta);
-            }
-        }
-        sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-        return sessions;
-    }
-    deleteSession(id) {
-        this._metaCache.delete(id);
-        const dir = this.sessionDir(id);
-        if (existsSync(dir)) {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    }
-    rotateOldSessions() {
-        const thirtyDaysAgo = new Date();
-        thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
-        const sessions = this.listSessions();
-        for (const session of sessions) {
-            const updatedAt = new Date(session.updatedAt);
-            if (updatedAt < thirtyDaysAgo) {
-                const historyPath = this.historyPath(session.id);
-                if (existsSync(historyPath)) {
-                    const content = readFileSync(historyPath, "utf-8");
-                    const compressed = gzipSync(content);
-                    const gzPath = join(this.baseDir, `${session.id}.jsonl.gz`);
-                    writeFileSync(gzPath, compressed);
-                    rmSync(historyPath);
-                }
-            }
-        }
-    }
-}

package/dist/modules/session/types.js

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

package/dist/modules/skills/index.js

@@ -1,2 +0,0 @@
-export { SkillsLoader } from "./loader";
-export { SkillsModule } from "./module";

package/dist/modules/skills/loader.js

@@ -1,72 +0,0 @@
-import { readdirSync, readFileSync, existsSync, statSync } from "fs";
-import { join } from "path";
-export class SkillsLoader {
-    loadFromDir(dirPath) {
-        if (!existsSync(dirPath))
-            return [];
-        const skills = [];
-        this.scanDir(dirPath, skills);
-        return skills;
-    }
-    scanDir(dirPath, skills) {
-        const entries = readdirSync(dirPath);
-        for (const entry of entries) {
-            const fullPath = join(dirPath, entry);
-            const stat = statSync(fullPath);
-            if (stat.isDirectory()) {
-                this.scanDir(fullPath, skills);
-                continue;
-            }
-            if (!entry.endsWith(".md") && !entry.endsWith(".skill.md"))
-                continue;
-            const content = readFileSync(fullPath, "utf-8");
-            const parsed = this.parseSkillFile(content, fullPath);
-            if (parsed)
-                skills.push(parsed);
-        }
-    }
-    parseSkillFile(content, sourcePath) {
-        const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-        if (!match)
-            return null;
-        const frontmatter = this.parseFrontmatter(match[1]);
-        if (!frontmatter.name)
-            return null;
-        if (frontmatter.mma_version && String(frontmatter.mma_version) !== "2") {
-            return null;
-        }
-        return {
-            name: frontmatter.name,
-            description: frontmatter.description || "",
-            keywords: frontmatter.keywords || [],
-            content: match[2].trim(),
-            sourcePath,
-        };
-    }
-    parseFrontmatter(yaml) {
-        const result = {};
-        for (const line of yaml.split("\n")) {
-            const kvMatch = line.match(/^(\w+):\s*(.+)$/);
-            if (kvMatch) {
-                const val = kvMatch[2].trim();
-                if (val.startsWith("[") && val.endsWith("]")) {
-                    result[kvMatch[1]] = val
-                        .slice(1, -1)
-                        .split(",")
-                        .map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
-                }
-                else {
-                    result[kvMatch[1]] = val.replace(/^['"]|['"]$/g, "");
-                }
-            }
-        }
-        return result;
-    }
-    loadFromAllSources(builtinDir, globalDir, projectDir) {
-        return [
-            ...this.loadFromDir(builtinDir),
-            ...this.loadFromDir(globalDir),
-            ...this.loadFromDir(projectDir),
-        ];
-    }
-}

package/dist/modules/skills/matcher.js

@@ -1,27 +0,0 @@
-const MIN_WORD_LENGTH = 4;
-export class SkillsMatcher {
-    match(taskDescription, skills, maxResults = 3) {
-        const taskWords = taskDescription.toLowerCase().split(/\W+/).filter(w => w.length >= MIN_WORD_LENGTH);
-        const scored = skills.map(skill => {
-            const allKeywords = [
-                skill.name.toLowerCase(),
-                skill.description.toLowerCase(),
-                ...skill.keywords.map(k => k.toLowerCase()),
-            ];
-            let score = 0;
-            for (const word of taskWords) {
-                for (const kw of allKeywords) {
-                    if (kw === word || (kw.length >= MIN_WORD_LENGTH && kw.includes(word))) {
-                        score++;
-                    }
-                }
-            }
-            return { skill, score };
-        });
-        return scored
-            .filter(s => s.score > 0)
-            .sort((a, b) => b.score - a.score)
-            .slice(0, maxResults)
-            .map(s => s.skill);
-    }
-}

package/dist/modules/skills/module.js

@@ -1,129 +0,0 @@
-import { t } from "../../i18n/index";
-export class SkillsModule {
-    name = "skills";
-    availableSkills;
-    loadedSkills = new Map();
-    budget;
-    currentTokens = 0;
-    constructor(availableSkills, budget) {
-        this.availableSkills = availableSkills;
-        this.budget = budget;
-    }
-    loadByName(name) {
-        if (this.loadedSkills.has(name)) {
-            return { success: false, message: t("skill.already_loaded", { name }) };
-        }
-        const skill = this.availableSkills.find((s) => s.name === name);
-        if (!skill) {
-            return { success: false, message: t("skill.not_found", { name }) };
-        }
-        return this.tryLoad(skill);
-    }
-    unload(name) {
-        const skill = this.loadedSkills.get(name);
-        if (!skill)
-            return false;
-        this.loadedSkills.delete(name);
-        this.currentTokens -= this.estimateTokens(skill.content);
-        return true;
-    }
-    getLoaded() {
-        return Array.from(this.loadedSkills.values());
-    }
-    getAvailable() {
-        return this.availableSkills;
-    }
-    findByName(name) {
-        return this.availableSkills.find((s) => s.name === name);
-    }
-    search(query) {
-        const q = query.toLowerCase();
-        return this.availableSkills.filter((s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q));
-    }
-    getBudget() {
-        return {
-            used: this.currentTokens,
-            total: this.budget,
-            remaining: this.budget - this.currentTokens,
-        };
-    }
-    getSkillContent(name) {
-        const skill = this.loadedSkills.get(name);
-        return skill ? skill.content : null;
-    }
-    getSystemPromptBlock() {
-        const lines = [];
-        if (this.availableSkills.length > 0) {
-            lines.push("[Available Skills]");
-            lines.push(t("skill.prompt_hint"));
-            for (const skill of this.availableSkills) {
-                const desc = skill.description.slice(0, 80);
-                lines.push(`- ${skill.name}: ${desc}`);
-            }
-        }
-        if (this.loadedSkills.size > 0) {
-            lines.push("");
-            lines.push("[Loaded Skills]");
-            for (const skill of this.loadedSkills.values()) {
-                lines.push(`--- ${skill.name} (${this.estimateTokens(skill.content)} tokens) ---`);
-                lines.push(skill.content);
-                lines.push("");
-            }
-        }
-        if (lines.length === 0)
-            return null;
-        const content = lines.join("\n");
-        const tokens = this.estimateTokens(content);
-        return {
-            content,
-            priority: "high",
-            essential: false,
-            estimatedTokens: tokens,
-        };
-    }
-    getPlugin() {
-        return {
-            name: "skills",
-            onSessionStart: (_ctx) => { },
-            onBeforeThink: (_ctx) => { },
-        };
-    }
-    tryLoad(skill) {
-        const tokens = this.estimateTokens(skill.content);
-        if (tokens > this.budget) {
-            return {
-                success: false,
-                message: t("skill.too_large", {
-                    name: skill.name,
-                    tokens,
-                    budget: this.budget,
-                }),
-            };
-        }
-        if (this.currentTokens + tokens > this.budget) {
-            const remaining = this.budget - this.currentTokens;
-            return {
-                success: false,
-                message: t("skill.exceeds_budget", {
-                    name: skill.name,
-                    tokens,
-                    remaining,
-                }),
-            };
-        }
-        this.loadedSkills.set(skill.name, skill);
-        this.currentTokens += tokens;
-        return {
-            success: true,
-            message: t("skill.loaded", {
-                name: skill.name,
-                tokens,
-                remaining: this.budget - this.currentTokens,
-            }),
-            skill,
-        };
-    }
-    estimateTokens(text) {
-        return Math.ceil(text.length / 4);
-    }
-}

package/dist/modules/types.js

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

package/dist/modules/updater/checker.js

@@ -1,96 +0,0 @@
-import { platform } from "os";
-import { resolveSpawnCommand } from "../lsp/command";
-/** Numeric semver comparison (x.y.z, prerelease ignored). */
-export function semverGt(a, b) {
-    const pa = a
-        .replace(/^v/, "")
-        .split(/[.-]/)
-        .map((p) => Number.parseInt(p, 10) || 0);
-    const pb = b
-        .replace(/^v/, "")
-        .split(/[.-]/)
-        .map((p) => Number.parseInt(p, 10) || 0);
-    for (let i = 0; i < 3; i++) {
-        const na = pa[i] ?? 0;
-        const nb = pb[i] ?? 0;
-        if (na !== nb)
-            return na > nb;
-    }
-    return false;
-}
-const defaultRunner = async (command, args, options) => {
-    const { execFile } = await import("child_process");
-    return new Promise((resolve) => {
-        execFile(command, args, options, (err) => resolve({ error: err?.message }));
-    });
-};
-export class Updater {
-    currentVersion;
-    packageName;
-    runner;
-    constructor(currentVersion, packageName, runner) {
-        this.currentVersion = currentVersion;
-        this.packageName = packageName;
-        this.runner = runner ?? defaultRunner;
-    }
-    getCurrentVersion() {
-        return this.currentVersion;
-    }
-    getPackageName() {
-        return this.packageName;
-    }
-    async check() {
-        try {
-            const response = await fetch(`https://registry.npmjs.org/${this.packageName}`, {
-                headers: { Accept: "application/vnd.npm.install-v1+json" },
-                signal: AbortSignal.timeout(5000),
-            });
-            if (!response.ok) {
-                return {
-                    updateAvailable: false,
-                    current: this.currentVersion,
-                    error: `HTTP ${response.status}`,
-                };
-            }
-            const data = await response.json();
-            const latest = data["dist-tags"]?.latest;
-            if (!latest) {
-                return { updateAvailable: false, current: this.currentVersion, error: "No latest tag" };
-            }
-            const updateAvailable = semverGt(latest, this.currentVersion);
-            return { updateAvailable, current: this.currentVersion, latest };
-        }
-        catch (e) {
-            return { updateAvailable: false, current: this.currentVersion, error: e.message };
-        }
-    }
-    /**
-     * Install the latest version globally via `npm install -g`.
-     * Returns an InstallResult (never throws).
-     */
-    async install(latest) {
-        try {
-            const { command, args } = this.buildInstallCommand(latest);
-            const res = await this.runner(command, args, {
-                timeout: 120000,
-                windowsHide: true,
-            });
-            if (res.error)
-                return { success: false, error: res.error };
-            return { success: true, installed: latest };
-        }
-        catch (e) {
-            const msg = e?.message ?? String(e);
-            return { success: false, error: msg.split("\n")[0] };
-        }
-    }
-    buildInstallCommand(latest) {
-        const npmArgs = ["install", "-g", `${this.packageName}@${latest}`];
-        const command = resolveSpawnCommand("npm");
-        if (platform() === "win32" && /\.(cmd|bat)$/i.test(command)) {
-            // Node cannot spawn .cmd/.bat shims directly (spawn EINVAL) — route via cmd.exe.
-            return { command: "cmd.exe", args: ["/c", command, ...npmArgs] };
-        }
-        return { command, args: npmArgs };
-    }
-}

package/dist/modules/updater/index.js

@@ -1,2 +0,0 @@
-export { Updater } from "./checker";
-export { UpdaterModule } from "./module";

package/dist/modules/updater/module.js

@@ -1,116 +0,0 @@
-import { Updater } from "./checker";
-import { t } from "../../i18n/index";
-import { pc } from "../../ui/colors";
-/**
- * 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
- * version is installed globally via `npm install -g` in the background and
- * the user is notified; the running process keeps working on the old version
- * until the next launch.
- */
-export class UpdaterModule {
-    name = "updater";
-    updater;
-    config;
-    logger;
-    started = false;
-    timer = null;
-    /** Promise of the current run-loop pass (resolves when it settles). */
-    idlePromise = null;
-    /** Test hook: disable real npm installs. */
-    installEnabled = true;
-    constructor(config, currentVersion, packageName, logger, installRunner) {
-        this.config = config;
-        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)),
-        };
-    }
-    /** Test hook: prevent the module from actually running npm install. */
-    setInstallEnabled(enabled) {
-        this.installEnabled = enabled;
-    }
-    getUpdater() {
-        return this.updater;
-    }
-    isStarted() {
-        return this.started;
-    }
-    /**
-     * Start the background check. Returns immediately (fire-and-forget) so the
-     * caller never blocks on the registry. Use `intervalMs > 0` for a permanent
-     * re-check loop (the "auto-update daemon" behavior).
-     */
-    start() {
-        if (this.started || !this.config.enabled)
-            return;
-        this.started = true;
-        this.idlePromise = this.runLoop();
-    }
-    stop() {
-        this.started = false;
-        if (this.timer) {
-            clearTimeout(this.timer);
-            this.timer = null;
-        }
-    }
-    /**
-     * Wait for the current check/install cycle to settle, bounded by timeoutMs.
-     * Used by one-shot CLI runs so a background `npm install -g` isn't killed by
-     * process.exit() before it completes. No-op when the module never started.
-     */
-    async waitForIdle(timeoutMs = 130000) {
-        const idle = this.idlePromise;
-        if (!idle)
-            return;
-        await Promise.race([idle, new Promise((r) => setTimeout(r, timeoutMs))]);
-    }
-    async runLoop() {
-        while (this.started) {
-            await this.checkOnce();
-            if (!this.started)
-                return;
-            if (this.config.intervalMs > 0) {
-                await new Promise((r) => (this.timer = setTimeout(r, this.config.intervalMs)));
-            }
-            else {
-                this.started = false;
-            }
-        }
-    }
-    /** Perform a single check; if an update is available, optionally install it. */
-    async runOnce() {
-        const result = await this.updater.check();
-        if (result.error) {
-            this.logger.info(t("updater.check_error", { error: result.error }));
-            return;
-        }
-        if (!result.updateAvailable || !result.latest)
-            return;
-        if (this.config.autoInstall && this.installEnabled) {
-            this.logger.info(t("updater.installing", {
-                current: result.current,
-                latest: result.latest,
-            }));
-            const install = await this.updater.install(result.latest);
-            if (install.success) {
-                this.logger.info(t("updater.installed", { current: result.current, latest: result.latest }));
-            }
-            else {
-                this.logger.warn(t("updater.install_failed", {
-                    current: result.current,
-                    latest: result.latest,
-                    error: install.error ?? "",
-                }));
-            }
-        }
-        else {
-            this.logger.info(t("updater.available", { current: result.current, latest: result.latest }));
-        }
-    }
-    async checkOnce() {
-        await this.runOnce();
-    }
-}

package/dist/modules/user-profile/compressor.js

@@ -1,16 +0,0 @@
-export class ProfileCompressor {
-    compress(info) {
-        const parts = [
-            `OS: ${info.os}`,
-            `Shell: ${info.shell}`,
-            `Platform: ${info.platform}`,
-        ];
-        if (Object.keys(info.preferences).length > 0) {
-            const prefs = Object.entries(info.preferences)
-                .map(([k, v]) => `${k}=${v}`)
-                .join(",");
-            parts.push(`Prefs: ${prefs}`);
-        }
-        return parts.join(", ");
-    }
-}

package/dist/modules/user-profile/index.js

@@ -1 +0,0 @@
-export { UserProfile } from "./profile";