micro-models-agent 0.28.8 → 0.28.17

package/dist/cli/commands.js

@@ -0,0 +1,333 @@
+import { Command } from "commander";
+import { bootstrap } from "../core/bootstrap";
+import { saveConfig } from "../config/config";
+import { runSetup } from "./setup";
+import { t } from "../i18n/index";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { existsSync, readFileSync } from "fs";
+import { createSecurityCommand } from "./security-commands";
+import { fileURLToPath } from "url";
+function readVersion() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, "..", "..", "package.json"),
+        join(here, "..", "package.json"),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            try {
+                const raw = JSON.parse(readFileSync(p, "utf8"));
+                if (raw.version)
+                    return raw.version;
+            }
+            catch {
+                // Broken package.json — fall through to the next candidate
+            }
+        }
+    }
+    return "0.0.0";
+}
+const version = readVersion();
+export function createProgram() {
+    const program = new Command()
+        .name("mma")
+        .description(t("cli.description"))
+        .version(version)
+        .option("--no-agents-md", t("cli.no_agents_md"))
+        .option("-d, --dir <path>", t("cli.dir"))
+        .option("-e, --exit-on-complete", t("cli.exit_on_complete"))
+        .option("-j, --json", t("cli.json"));
+    program
+        .command("init")
+        .description(t("cli.init"))
+        .action(async () => {
+        const answers = await runSetup();
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config } = await bootstrap();
+        config.provider.type = answers.provider;
+        config.provider.baseUrl = answers.apiBase;
+        config.provider.apiKey = answers.apiKey;
+        config.model = answers.model;
+        config.contextWindow = answers.contextWindow;
+        config.maxToolIterations = answers.maxToolIterations;
+        config.locale = answers.locale;
+        // Apply security settings from wizard
+        if (config.security) {
+            config.security.enabled =
+                answers.securityBashBlock ||
+                    answers.securityFlagsBlock ||
+                    !answers.securityPathsDeny;
+            config.security.bash.enabled = config.security.enabled;
+            config.security.bash.blockDangerousFlags = answers.securityFlagsBlock;
+            if (answers.securityBashBlock) {
+                config.security.bash.blacklist = [
+                    ...new Set([
+                        ...config.security.bash.blacklist,
+                        "rm",
+                        "dd",
+                        "chmod",
+                        "wget",
+                        "curl",
+                        "scp",
+                        "ssh",
+                        "nc",
+                        "netcat",
+                        "sudo",
+                        "su",
+                        "kill",
+                        "pkill",
+                        "killall",
+                        "shutdown",
+                        "reboot",
+                    ]),
+                ];
+            }
+            if (!answers.securityPathsDeny) {
+                config.security.paths.denied = [];
+            }
+        }
+        saveConfig(config, configPath);
+        console.log(t("cli.config_saved"));
+    });
+    const configCmd = program
+        .command("config")
+        .description(t("cli.manage_config"));
+    configCmd
+        .command("set")
+        .argument("<key>", t("cli.config_key"))
+        .argument("<value>", "Config value")
+        .description(t("cli.set_value"))
+        .action(async (key, value) => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config } = await bootstrap();
+        const keys = key.split(".");
+        let obj = config;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (!(keys[i] in obj))
+                obj[keys[i]] = {};
+            obj = obj[keys[i]];
+        }
+        const lastKey = keys[keys.length - 1];
+        if (value === "true")
+            obj[lastKey] = true;
+        else if (value === "false")
+            obj[lastKey] = false;
+        else if (/^\d+$/.test(value))
+            obj[lastKey] = parseInt(value, 10);
+        else if (/^\d+\.\d+$/.test(value))
+            obj[lastKey] = parseFloat(value);
+        else
+            obj[lastKey] = value;
+        saveConfig(config, configPath);
+        console.log(t("cli.set_done", { key, value }));
+    });
+    configCmd
+        .command("show")
+        .description(t("cli.show_config"))
+        .action(async () => {
+        const { config } = await bootstrap();
+        console.log(JSON.stringify(config, null, 2));
+    });
+    const model = program.command("model").description(t("cli.manage_models"));
+    model
+        .command("list")
+        .description(t("cli.list_models"))
+        .action(async () => {
+        const { config } = await bootstrap();
+        console.log(t("cli.current_model"), config.model);
+        // Fetch available models from provider
+        const { OpenAICompatProvider } = await import("../llm/openai-compat");
+        const provider = new OpenAICompatProvider({
+            model: config.model,
+            baseUrl: config.provider.baseUrl,
+            apiKey: config.provider.apiKey,
+            contextWindow: config.contextWindow,
+        });
+        const spinner = (await import("../ui/spinner")).Spinner;
+        const s = new spinner();
+        s.start(t("cli.fetching_models"));
+        try {
+            const models = await provider.listModels();
+            s.stop();
+            if (models.length > 0) {
+                console.log(t("cli.available_models"));
+                const { getCertMark } = await import("../modules/certification/manifest");
+                for (const m of models) {
+                    const marker = m === config.model ? "* " : "  ";
+                    const mark = getCertMark(m, config.provider.baseUrl, version);
+                    const cert = mark === "certified" ? "✔" : mark === "stale" ? "○" : "·";
+                    console.log(` ${marker}${cert} ${m}`);
+                }
+            }
+            else {
+                console.log(t("cli.no_models_found"));
+            }
+        }
+        catch (err) {
+            s.stop();
+            console.log(t("cli.model_fetch_failed", { error: String(err) }));
+        }
+        console.log(t("cli.model_hint"));
+    });
+    model
+        .command("use")
+        .argument("<name>", "Model name")
+        .description(t("cli.set_model"))
+        .action(async (name) => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config } = await bootstrap();
+        config.model = name;
+        saveConfig(config, configPath);
+        console.log(t("cli.model_set", { name }));
+    });
+    model
+        .command("certify")
+        .argument("<name>", "Model name")
+        .option("--provider-url <url>", t("cli.cert_provider_url"))
+        .option("--provider-key <key>", t("cli.cert_provider_key"))
+        .option("--context-window <n>", t("cli.cert_context_window"))
+        .option("--tags <tags>", t("cli.cert_tags"), "core")
+        .option("--reps <n>", t("cli.cert_reps"))
+        .option("--force", t("cli.cert_force"))
+        .option("--clean", t("cli.cert_clean"))
+        .description(t("cli.certify"))
+        .action(async (name, cmdOpts) => {
+        const { config } = await bootstrap();
+        const { certify, parseTags } = await import("../modules/certification/cli");
+        await certify({
+            name,
+            providerUrl: cmdOpts.providerUrl,
+            providerKey: cmdOpts.providerKey,
+            contextWindow: cmdOpts.contextWindow
+                ? parseInt(cmdOpts.contextWindow, 10)
+                : undefined,
+            tags: parseTags(cmdOpts.tags),
+            reps: cmdOpts.reps ? parseInt(cmdOpts.reps, 10) : 3,
+            force: cmdOpts.force === true,
+            clean: cmdOpts.clean === true,
+            config,
+        });
+    });
+    model
+        .command("cert-status")
+        .argument("<name>", "Model name")
+        .description(t("cli.cert_status"))
+        .action(async (name) => {
+        const { config } = await bootstrap();
+        const { certStatus } = await import("../modules/certification/cli");
+        await certStatus(name, config);
+    });
+    model
+        .command("cert-list")
+        .description(t("cli.cert_list"))
+        .action(async () => {
+        const { certList } = await import("../modules/certification/cli");
+        await certList();
+    });
+    model
+        .command("uncertify")
+        .argument("<name>", "Model name")
+        .description(t("cli.cert_uncertify"))
+        .action(async (name) => {
+        const { config } = await bootstrap();
+        const { uncertify } = await import("../modules/certification/cli");
+        await uncertify(name, config);
+    });
+    // Context window command
+    program
+        .command("context")
+        .description(t("cli.manage_context"))
+        .argument("<size>", "Context window size in tokens")
+        .action(async (size) => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config } = await bootstrap();
+        const contextWindow = parseInt(size, 10);
+        if (isNaN(contextWindow) || contextWindow < 1024) {
+            console.log(t("cli.invalid_context_size"));
+            return;
+        }
+        config.contextWindow = contextWindow;
+        saveConfig(config, configPath);
+        console.log(t("cli.context_set", { size: contextWindow }));
+    });
+    const provider = program
+        .command("provider")
+        .description(t("cli.manage_providers"));
+    provider
+        .command("list")
+        .description(t("cli.list_providers"))
+        .action(async () => {
+        const { config } = await bootstrap();
+        console.log(t("cli.current_provider"), config.provider.type);
+        console.log(t("cli.base_url"), config.provider.baseUrl);
+    });
+    provider
+        .command("use")
+        .argument("<name>", "Provider name")
+        .description(t("cli.set_provider"))
+        .action(async (name) => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config } = await bootstrap();
+        config.provider.type = name;
+        saveConfig(config, configPath);
+        console.log(t("cli.provider_set", { name }));
+    });
+    const session = program
+        .command("session")
+        .description(t("cli.manage_sessions"));
+    session
+        .command("list")
+        .description(t("cli.list_sessions"))
+        .action(async () => {
+        const { sessionManager } = await bootstrap();
+        const sessions = sessionManager.list();
+        if (sessions.length === 0) {
+            console.log(t("session.no_sessions"));
+            return;
+        }
+        const active = sessionManager.getActive();
+        for (const s of sessions) {
+            const marker = s.id === active ? "*" : " ";
+            console.log(` ${marker} ${s.id.slice(0, 12)}  ${s.name}  ${s.messageCount} msgs  ${s.updatedAt.slice(0, 10)}`);
+        }
+    });
+    session
+        .command("show")
+        .argument("<id>", "Session id")
+        .description(t("cli.show_details"))
+        .action(async (id) => {
+        const { sessionManager } = await bootstrap();
+        const meta = sessionManager.get(id);
+        if (!meta) {
+            console.log(t("session.not_found", { id }));
+            return;
+        }
+        console.log(`ID:           ${meta.id}`);
+        console.log(`Name:         ${meta.name}`);
+        console.log(`Created:      ${meta.createdAt}`);
+        console.log(`Updated:      ${meta.updatedAt}`);
+        console.log(`Messages:     ${meta.messageCount}`);
+        console.log(`Model:        ${meta.model}`);
+        console.log(`Context:      ${meta.contextWindow}`);
+        console.log(`Project:      ${meta.projectDir}`);
+    });
+    session
+        .command("delete")
+        .argument("<id>", "Session id")
+        .description(t("cli.delete_session"))
+        .action(async (id) => {
+        const { sessionManager } = await bootstrap();
+        sessionManager.delete(id);
+        console.log(t("session.deleted", { id }));
+    });
+    // Add security commands
+    createSecurityCommand(program);
+    program
+        .argument("[prompt...]", "Prompt to execute")
+        .description("Run a single prompt")
+        .action((prompt) => {
+        /* Handled by main.ts after program.parse() */
+    });
+    return program;
+}

package/dist/cli/completer.js

@@ -0,0 +1,168 @@
+import { readdirSync, statSync } from 'fs';
+import { join } from 'path';
+export class SlashCommandProvider {
+    name = 'slash-commands';
+    commands;
+    constructor(commands) {
+        this.commands = commands;
+    }
+    match(ctx) {
+        return ctx.tokenIndex === 0 && ctx.line.startsWith('/');
+    }
+    complete(ctx) {
+        return this.commands
+            .filter(c => c.startsWith(ctx.partial.slice(1)))
+            .map(c => `/${c}`);
+    }
+}
+export class SubcommandProvider {
+    name = 'subcommands';
+    command;
+    subcommands;
+    constructor(command, subcommands) {
+        this.command = command;
+        this.subcommands = subcommands;
+    }
+    match(ctx) {
+        return ctx.tokenIndex === 1 && ctx.tokens[0] === `/${this.command}`;
+    }
+    complete(ctx) {
+        return this.subcommands.filter(s => s.startsWith(ctx.partial));
+    }
+}
+export class ModelArgProvider {
+    name = 'model-args';
+    models;
+    constructor(models) {
+        this.models = models;
+    }
+    match(ctx) {
+        return ctx.tokenIndex === 2 && (ctx.tokens[0] === '/model' || ctx.tokens[0] === '/config');
+    }
+    complete(ctx) {
+        return this.models.filter(m => m.startsWith(ctx.partial));
+    }
+}
+export class ConfigKeyProvider {
+    name = 'config-keys';
+    keys;
+    constructor(keys) {
+        this.keys = keys;
+    }
+    match(ctx) {
+        return ctx.tokenIndex >= 1 && ctx.tokens[0] === '/config' && ctx.tokens[1] === 'set';
+    }
+    complete(ctx) {
+        return this.keys.filter(k => k.startsWith(ctx.partial));
+    }
+}
+export class FilePathProvider {
+    name = 'file-paths';
+    match(ctx) {
+        return ctx.partial.includes('/') || ctx.partial.includes('\\');
+    }
+    complete(ctx) {
+        try {
+            const cwd = process.cwd();
+            const partialPath = ctx.partial;
+            const lastSlash = Math.max(partialPath.lastIndexOf('/'), partialPath.lastIndexOf('\\'));
+            const dirPath = lastSlash > 0 ? partialPath.slice(0, lastSlash) : '.';
+            const prefix = lastSlash > 0 ? partialPath.slice(0, lastSlash + 1) : '';
+            const fullPath = join(cwd, dirPath);
+            const entries = readdirSync(fullPath);
+            const matches = [];
+            for (const entry of entries) {
+                const entryPath = join(fullPath, entry);
+                const stat = statSync(entryPath);
+                const completion = prefix + entry + (stat.isDirectory() ? '/' : '');
+                if (completion.startsWith(ctx.partial)) {
+                    matches.push(completion);
+                }
+            }
+            return matches.slice(0, 20);
+        }
+        catch {
+            return [];
+        }
+    }
+}
+export class ProviderArgProvider {
+    name = 'provider-args';
+    providers;
+    constructor(providers) {
+        this.providers = providers;
+    }
+    match(ctx) {
+        return ctx.tokenIndex === 2 && ctx.tokens[0] === '/provider' && ctx.tokens[1] === 'use';
+    }
+    complete(ctx) {
+        return this.providers.filter(p => p.startsWith(ctx.partial));
+    }
+}
+export class SessionNameProvider {
+    name = 'session-names';
+    getNames;
+    constructor(getNames) {
+        this.getNames = getNames;
+    }
+    match(ctx) {
+        return ctx.tokenIndex >= 1 && ctx.tokens[0] === '/resume';
+    }
+    complete(ctx) {
+        const names = this.getNames();
+        if (!ctx.partial)
+            return names;
+        return names.filter(n => n.toLowerCase().includes(ctx.partial.toLowerCase()));
+    }
+}
+export class SkillNameProvider {
+    name = 'skill-names';
+    skillsModule;
+    constructor(skillsModule) {
+        this.skillsModule = skillsModule;
+    }
+    match(ctx) {
+        return ctx.tokenIndex >= 2 && ctx.tokens[0] === '/skill' &&
+            (ctx.tokens[1] === 'load' || ctx.tokens[1] === 'unload');
+    }
+    complete(ctx) {
+        const subcmd = ctx.tokens[1];
+        if (subcmd === 'load') {
+            const available = this.skillsModule.getAvailable();
+            const names = available.map(s => s.name);
+            if (!ctx.partial)
+                return names;
+            return names.filter(n => n.toLowerCase().includes(ctx.partial.toLowerCase()));
+        }
+        if (subcmd === 'unload') {
+            const loaded = this.skillsModule.getLoaded();
+            const names = loaded.map(s => s.name);
+            if (!ctx.partial)
+                return names;
+            return names.filter(n => n.toLowerCase().includes(ctx.partial.toLowerCase()));
+        }
+        return [];
+    }
+}
+export class Completer {
+    providers = [];
+    registerProvider(provider) {
+        this.providers.push(provider);
+    }
+    complete(line) {
+        const cursor = line.length;
+        const tokens = line.split(/\s+/);
+        const partial = tokens[tokens.length - 1] || '';
+        const tokenIndex = tokens.length - 1;
+        const ctx = { line, cursor, tokens, partial, tokenIndex };
+        for (const provider of this.providers) {
+            if (provider.match(ctx)) {
+                const results = provider.complete(ctx);
+                if (results.length > 0) {
+                    return [results, partial];
+                }
+            }
+        }
+        return [[], partial];
+    }
+}

package/dist/cli/index.js

@@ -0,0 +1,2 @@
+export { main } from './main';
+export { createProgram } from './commands';

package/dist/cli/main.js

@@ -0,0 +1,140 @@
+import { createProgram } from "./commands";
+import { bootstrap } from "../core/bootstrap";
+import { Repl } from "./repl";
+import { formatMarkdown } from "../ui/md-formatter";
+import { Renderer } from "../ui/renderer";
+import { runSetup } from "./setup";
+import { saveConfig, loadConfig } from "../config/config";
+import { t } from "../i18n/index";
+import { pc } from "../ui/colors";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+async function main() {
+    const program = createProgram();
+    program.parse(process.argv);
+    const cmdNames = new Set(program.commands.map((c) => c.name()));
+    const opts = program.opts();
+    const noAgentsMd = opts.noAgentsMd === true;
+    const projectDir = opts.dir;
+    const exitOnComplete = opts.exitOnComplete === true;
+    const jsonMode = opts.json === true;
+    const isSubcommand = program.args.length > 0 && cmdNames.has(program.args[0]);
+    if (isSubcommand) {
+        return;
+    }
+    if (program.args.length > 0) {
+        const prompt = program.args.join(" ");
+        const { agent, config } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
+        if (jsonMode) {
+            const result = await agent.run(prompt);
+            agent.shutdown();
+            process.stdout.write(JSON.stringify({
+                success: result.success,
+                text: result.text,
+                error: result.error ?? null,
+                iterationCount: result.iterationCount,
+                contextUsed: result.contextUsed ?? null,
+                contextLimit: result.contextLimit ?? null,
+                promptTokens: result.promptTokens ?? null,
+                completionTokens: result.completionTokens ?? null,
+                totalTokens: result.totalTokens ?? null,
+            }, null, 2));
+            process.stdout.write("\n");
+            process.exit(result.success ? 0 : 1);
+        }
+        const renderer = new Renderer({
+            spinner: config.ui?.spinner ?? true,
+            toolStyle: config.ui?.toolStyle ?? "inline",
+        });
+        const result = await agent.run(prompt, (chunk) => renderer.text(chunk), (meta) => renderer.meta(meta), (ev) => {
+            if (ev.type === "start") {
+                renderer.toolStart(ev.tool, ev.args);
+            }
+            else {
+                renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta);
+            }
+        }, (phase) => {
+            if (phase === "thinking") {
+                renderer.thinkingStart();
+            }
+            else {
+                renderer.thinkingEnd();
+            }
+        });
+        renderer.flush();
+        if (result.success) {
+            if (!result.text) {
+                console.log(pc.yellow(t("cli.no_output")));
+            }
+        }
+        else {
+            console.error(`${t("error.prefix")}${result.error}`);
+            if (result.text) {
+                console.log(formatMarkdown(result.text));
+            }
+            process.exit(1);
+        }
+        agent.shutdown();
+    }
+    else {
+        const configPath = join(homedir(), ".mma", "config.json");
+        if (!existsSync(configPath)) {
+            console.log(pc.yellow("\n  " + t("cli.first_run") + "\n"));
+            const answers = await runSetup();
+            const config = loadConfig({
+                configDir: join(homedir(), ".mma"),
+                projectConfigPath: projectDir
+                    ? join(projectDir, ".mmrc")
+                    : join(process.cwd(), ".mmrc"),
+            });
+            config.provider.type = answers.provider;
+            config.provider.baseUrl = answers.apiBase;
+            config.provider.apiKey = answers.apiKey;
+            config.model = answers.model;
+            config.contextWindow = answers.contextWindow;
+            config.maxToolIterations = answers.maxToolIterations;
+            config.locale = answers.locale;
+            if (config.security) {
+                config.security.enabled =
+                    answers.securityBashBlock ||
+                        answers.securityFlagsBlock ||
+                        !answers.securityPathsDeny;
+                config.security.bash.enabled = config.security.enabled;
+                config.security.bash.blockDangerousFlags = answers.securityFlagsBlock;
+                if (answers.securityBashBlock) {
+                    config.security.bash.blacklist = [
+                        ...new Set([
+                            ...config.security.bash.blacklist,
+                            "rm",
+                            "dd",
+                            "chmod",
+                            "wget",
+                            "curl",
+                            "scp",
+                            "ssh",
+                            "nc",
+                            "netcat",
+                            "sudo",
+                            "su",
+                            "kill",
+                            "pkill",
+                            "killall",
+                            "shutdown",
+                            "reboot",
+                        ]),
+                    ];
+                }
+                if (!answers.securityPathsDeny) {
+                    config.security.paths.denied = [];
+                }
+            }
+            saveConfig(config, configPath);
+        }
+        const { agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, logger, } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
+        const repl = new Repl(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger);
+        repl.start();
+    }
+}
+main();
+export { main };