@otto-code/brain 0.7.5

package/dist/commands/lifecycle.js

@@ -0,0 +1,194 @@
+/**
+ * Service lifecycle commands. `serve` runs the brain in the foreground; `start`
+ * launches it detached (the shape the Otto daemon uses to supervise a managed
+ * child); `stop`/`status` operate on the pid file. All honor the opt-in config —
+ * they are always explicit user actions, never auto-started.
+ */
+import { spawn } from "node:child_process";
+import { openSync } from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import { loadBrainConfig } from "../config/index.js";
+import { resolveBrainPaths } from "../config/paths.js";
+import { CommandError } from "../output/types.js";
+import { isProcessAlive, readRunningService, removePidFile, } from "../service/pid-lock.js";
+import { startService } from "../service/serve.js";
+import * as vram from "../vram.js";
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// ------------------------------------------------------------------------ serve
+export function addServeOptions(cmd) {
+    return cmd
+        .description("Host a model in the foreground (Ctrl+C to stop)")
+        .option("--model <fragment>", "model name fragment or catalog id");
+}
+export async function runServeCommand(options, _command) {
+    const config = loadBrainConfig();
+    const handle = await startService({
+        config,
+        modelNeedle: options.model,
+        onLog: (line) => process.stderr.write(`  ${line}\n`),
+    });
+    const scheme = handle.secure ? "https" : "http";
+    process.stdout.write(`router listening on ${scheme}://${handle.displayHost}:${handle.port}\n`);
+    process.stdout.write(`ready: ${handle.model.displayName}, ${vram.formatGiB(handle.supervisor.vramAtReadyBytes ?? 0)} VRAM in use\n`);
+    process.stdout.write("press Ctrl+C to stop\n");
+    const shutdown = async () => {
+        process.stdout.write("\nstopping…\n");
+        await handle.stop();
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+export const lifecycleSchema = {
+    idField: "pid",
+    columns: [
+        {
+            header: "STATUS",
+            field: "status",
+            width: 10,
+            color: (v) => (v === "running" ? "green" : "yellow"),
+        },
+        { header: "PID", field: "pid", width: 8, align: "right" },
+        { header: "HOST", field: "host", width: 16 },
+        { header: "PORT", field: "port", width: 6, align: "right" },
+    ],
+};
+export function addStartOptions(cmd) {
+    return cmd
+        .description("Start the brain service detached")
+        .option("--model <fragment>", "model name fragment or catalog id");
+}
+// Rebuild the sub-command path this command was invoked under (excluding the
+// root program and the leaf verb) so the detached child is spawned with the same
+// prefix. Standalone `otto-brain start` → [] (serve is a root verb); integrated
+// `otto brain start` → ["brain"] (so the child runs `otto brain serve`, not the
+// non-existent `otto serve`).
+function invocationVerbPrefix(command) {
+    const names = [];
+    let ancestor = command?.parent;
+    while (ancestor && ancestor.parent) {
+        names.unshift(ancestor.name());
+        ancestor = ancestor.parent;
+    }
+    return names;
+}
+export async function runStartCommand(options, command) {
+    const existing = readRunningService();
+    if (existing) {
+        throw new CommandError({
+            code: "ALREADY_RUNNING",
+            message: `brain already running (pid ${existing.pid}) on ${existing.host}:${existing.port}`,
+            details: "stop it with `otto brain stop`",
+        });
+    }
+    const { logFile } = resolveBrainPaths();
+    const entry = process.argv[1];
+    const args = [...invocationVerbPrefix(command), "serve"];
+    if (options.model)
+        args.push("--model", options.model);
+    const out = openSync(logFile, "a");
+    const child = spawn(process.execPath, [entry, ...args], {
+        detached: true,
+        stdio: ["ignore", out, out],
+        windowsHide: true,
+    });
+    child.unref();
+    return {
+        type: "single",
+        data: { status: "starting", pid: child.pid ?? "-", host: "-", port: "-" },
+        schema: lifecycleSchema,
+    };
+}
+// ------------------------------------------------------------------------- stop
+export function addStopOptions(cmd) {
+    return cmd.description("Stop the running brain service");
+}
+export async function runStopCommand(_options, _command) {
+    const running = readRunningService();
+    if (!running) {
+        throw new CommandError({ code: "NOT_RUNNING", message: "no brain service is running" });
+    }
+    process.kill(running.pid, "SIGTERM");
+    removePidFile();
+    return {
+        type: "single",
+        data: { status: "stopped", pid: running.pid, host: running.host, port: running.port },
+        schema: lifecycleSchema,
+    };
+}
+// ---------------------------------------------------------------------- restart
+export function addRestartOptions(cmd) {
+    return cmd
+        .description("Restart the brain service detached")
+        .option("--model <fragment>", "model name fragment or catalog id");
+}
+export async function runRestartCommand(options, command) {
+    const running = readRunningService();
+    if (running) {
+        try {
+            process.kill(running.pid, "SIGTERM");
+        }
+        catch {
+            // already gone; fall through to a fresh start
+        }
+        // Wait for it to exit so the port is free before we respawn (up to ~3s).
+        for (let i = 0; i < 30 && isProcessAlive(running.pid); i++) {
+            await delay(100);
+        }
+        removePidFile();
+    }
+    return runStartCommand(options, command);
+}
+const statusSchema = {
+    idField: "pid",
+    columns: [
+        ...lifecycleSchema.columns,
+        { header: "HEALTH", field: "health", width: 10, color: (v) => (v === "ok" ? "green" : "red") },
+    ],
+};
+export function addStatusOptions(cmd) {
+    return cmd.description("Show whether the brain service is running");
+}
+function probeHealth(record) {
+    const secure = record.secure === true;
+    const lib = secure ? https : http;
+    // Probe the bind host (always locally reachable) and skip cert validation: a
+    // self-signed or MagicDNS cert would otherwise fail a local liveness check.
+    const options = {
+        host: record.host,
+        port: record.port,
+        path: "/health",
+        timeout: 3000,
+        ...(secure ? { rejectUnauthorized: false } : {}),
+    };
+    return new Promise((resolve) => {
+        const req = lib.get(options, (res) => {
+            res.resume();
+            const code = res.statusCode ?? 0;
+            resolve(code >= 200 && code < 300 ? "ok" : `http ${code}`);
+        });
+        req.on("timeout", () => {
+            req.destroy();
+            resolve("loading");
+        });
+        req.on("error", () => resolve("loading"));
+    });
+}
+export async function runStatusCommand(_options, _command) {
+    const running = readRunningService();
+    if (!running) {
+        return {
+            type: "single",
+            data: { status: "stopped", pid: "-", host: "-", port: "-", health: "-" },
+            schema: statusSchema,
+        };
+    }
+    const health = await probeHealth(running);
+    return {
+        type: "single",
+        data: { status: "running", pid: running.pid, host: running.host, port: running.port, health },
+        schema: statusSchema,
+    };
+}
+//# sourceMappingURL=lifecycle.js.map

package/dist/commands/pull.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `otto brain pull <model>` — download a model from the catalog into the managed
+ * models directory, using only Node's fetch (no external downloader). The catalog
+ * is the same one seeded from docs/candidate-models.md. `--list-quants` shows what
+ * quantizations the repo offers and `--quant <label>` downloads a specific one.
+ */
+import type { Command } from "commander";
+import type { AnyCommandResult } from "../output/index.js";
+export interface PullRow {
+    model: string;
+    repo: string;
+    path: string;
+    size: string;
+}
+export declare function addPullOptions(cmd: Command): Command;
+export interface PullOptionsInput {
+    file?: string;
+    quant?: string;
+    listQuants?: boolean;
+}
+export declare function runPullCommand(modelArg: string, options: PullOptionsInput, _command: Command): Promise<AnyCommandResult<PullRow>>;
+//# sourceMappingURL=pull.d.ts.map

package/dist/commands/pull.js

@@ -0,0 +1,135 @@
+import { loadBrainConfig, loadCatalog } from "../config/index.js";
+import { downloadRepoFiles, listRepoQuants, managedModelsDir, pullModel, resolveHfToken, } from "../models/index.js";
+import { CommandError } from "../output/types.js";
+import { formatBytes } from "../models/scan.js";
+const pullSchema = {
+    idField: "model",
+    columns: [
+        { header: "MODEL", field: "model", width: 32 },
+        { header: "REPO", field: "repo", width: 40 },
+        { header: "PATH", field: "path", width: 40 },
+        { header: "SIZE", field: "size", width: 10, align: "right" },
+    ],
+};
+const quantSchema = {
+    idField: "quant",
+    columns: [
+        { header: "QUANT", field: "quant", width: 12 },
+        { header: "SIZE", field: "size", width: 10, align: "right" },
+        { header: "FILES", field: "files", width: 6, align: "right" },
+    ],
+};
+function findCatalogModel(models, needle) {
+    const lower = needle.toLowerCase();
+    const exact = models.find((m) => m.id === needle || m.name.toLowerCase() === lower);
+    if (exact)
+        return exact;
+    const matches = models.filter((m) => m.id.toLowerCase().includes(lower) || m.name.toLowerCase().includes(lower));
+    if (!matches.length) {
+        throw new CommandError({ code: "NO_MATCH", message: `no catalog model matches "${needle}"` });
+    }
+    if (matches.length > 1) {
+        throw new CommandError({
+            code: "AMBIGUOUS",
+            message: `"${needle}" matches ${matches.length} catalog models`,
+            details: matches.map((m) => m.name).join(", "),
+        });
+    }
+    return matches[0];
+}
+export function addPullOptions(cmd) {
+    return cmd
+        .description("Download a model from the catalog")
+        .argument("<model>", "catalog id or name fragment")
+        .option("--file <name.gguf>", "explicit GGUF file name in the repo")
+        .option("--quant <label>", "download a specific quantization (e.g. Q5_K_M)")
+        .option("--list-quants", "list the quantizations the repo offers and exit");
+}
+export async function runPullCommand(modelArg, options, _command) {
+    const config = loadBrainConfig();
+    const catalog = loadCatalog();
+    const model = findCatalogModel(catalog.models, modelArg);
+    const token = resolveHfToken(config);
+    // Discover-and-choose paths both need the repo's quant listing.
+    if (options.listQuants || options.quant) {
+        const { quants, mmproj } = await listRepoQuants(model.hfRepo, token);
+        if (options.listQuants) {
+            const listing = {
+                type: "list",
+                data: quants.map((q) => ({
+                    quant: q.quant,
+                    size: formatBytes(q.sizeBytes),
+                    files: q.files.length,
+                })),
+                schema: quantSchema,
+            };
+            // withOutput infers one row type; the renderer is schema-driven, so a
+            // differently-shaped result renders correctly at runtime.
+            return listing;
+        }
+        const wanted = options.quant.toLowerCase();
+        const choice = quants.find((q) => q.quant.toLowerCase() === wanted);
+        if (!choice) {
+            throw new CommandError({
+                code: "NO_QUANT",
+                message: `${model.hfRepo} has no ${options.quant} - available: ${quants.map((q) => q.quant).join(", ") || "none"}`,
+            });
+        }
+        const files = [...choice.files, ...(mmproj ? mmproj.files : [])];
+        const total = choice.sizeBytes + (mmproj?.sizeBytes ?? 0);
+        let lastPct = -1;
+        const written = await downloadRepoFiles({
+            repo: model.hfRepo,
+            files,
+            destRoot: managedModelsDir(config),
+            token,
+            onProgress: (p) => {
+                const pct = total ? Math.floor((p.receivedBytes / total) * 100) : 0;
+                if (pct !== lastPct && pct % 5 === 0) {
+                    lastPct = pct;
+                    process.stderr.write(`  ${model.name} ${choice.quant}: ${pct}%\r`);
+                }
+            },
+        });
+        process.stderr.write("\n");
+        return {
+            type: "single",
+            data: {
+                model: `${model.name} (${choice.quant})`,
+                repo: model.hfRepo,
+                path: written[0] ?? "(already present)",
+                size: formatBytes(total),
+            },
+            schema: pullSchema,
+        };
+    }
+    const destRoot = managedModelsDir(config);
+    let lastPct = -1;
+    const localPath = await pullModel({
+        model,
+        destRoot,
+        file: options.file,
+        token,
+        onProgress: (p) => {
+            if (!p.totalBytes)
+                return;
+            const pct = Math.floor((p.receivedBytes / p.totalBytes) * 100);
+            if (pct !== lastPct && pct % 5 === 0) {
+                lastPct = pct;
+                process.stderr.write(`  ${model.name}: ${pct}%\r`);
+            }
+        },
+    });
+    process.stderr.write("\n");
+    return {
+        type: "single",
+        data: {
+            model: model.name,
+            repo: model.hfRepo,
+            path: localPath,
+            size: model.approxWeightsBytes ? formatBytes(model.approxWeightsBytes) : "-",
+        },
+        schema: pullSchema,
+    };
+}
+//# sourceMappingURL=pull.js.map

package/dist/commands/report.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `otto brain report` — write the HTML comparison report and print a per-model
+ * score table (newest run per model+config).
+ */
+import type { Command } from "commander";
+export declare function addReportOptions(cmd: Command): Command;
+export declare function runReportCommand(options: {
+    out?: string;
+}, _command: Command): Promise<void>;
+//# sourceMappingURL=report.d.ts.map

package/dist/commands/report.js

@@ -0,0 +1,34 @@
+import { CommandError } from "../output/types.js";
+import * as report from "../ops/report.js";
+import * as results from "../ops/results.js";
+export function addReportOptions(cmd) {
+    return cmd
+        .description("Write the HTML comparison report")
+        .option("--out <path>", "output HTML path");
+}
+export async function runReportCommand(options, _command) {
+    const records = results.latestPerConfig();
+    if (!records.length) {
+        throw new CommandError({
+            code: "NO_RESULTS",
+            message: "no results yet",
+            details: "run `otto brain bench --model <name>` first",
+        });
+    }
+    const { file, count } = report.write(options.out);
+    process.stdout.write(`\nwrote ${file}\n  ${count} run(s) charted, newest per model+config\n\n`);
+    const columns = results.taskColumns(records);
+    const pad = (s, n) => String(s).padEnd(n);
+    process.stdout.write(`  ${pad("model", 40)}${columns.map((c) => c.category.slice(0, 8).padStart(9)).join("")}${"overall".padStart(9)}\n`);
+    for (const record of records) {
+        const cells = columns
+            .map((c) => {
+            const task = record.tasks.find((t) => t.id === c.id);
+            return `${task ? `${(task.score * 100).toFixed(0)}%` : "-"}`.padStart(9);
+        })
+            .join("");
+        process.stdout.write(`  ${pad(record.model.displayName.slice(0, 39), 40)}${cells}${`${(record.overall * 100).toFixed(0)}%`.padStart(9)}\n`);
+    }
+    process.stdout.write("\n");
+}
+//# sourceMappingURL=report.js.map

package/dist/commands/rescore.d.ts

@@ -0,0 +1,11 @@
+/**
+ * `otto brain rescore` — re-grade archived benchmark transcripts with the current
+ * scorer, no GPU used. Surfaces scorer changes against what was recorded live.
+ */
+import type { Command } from "commander";
+export declare function addRescoreOptions(cmd: Command): Command;
+export declare function runRescoreCommand(options: {
+    run?: string;
+    execute?: boolean;
+}, _command: Command): Promise<void>;
+//# sourceMappingURL=rescore.d.ts.map

package/dist/commands/rescore.js

@@ -0,0 +1,48 @@
+import { CommandError } from "../output/types.js";
+import { rescoreRun } from "../bench/rescore.js";
+import * as archive from "../ops/archive.js";
+import * as results from "../ops/results.js";
+export function addRescoreOptions(cmd) {
+    return cmd
+        .description("Re-grade archived runs with the current scorer (no GPU)")
+        .option("--run <id>", "rescore a single archived run")
+        .option("--no-execute", "syntax-check generated code but do not run it");
+}
+export async function runRescoreCommand(options, _command) {
+    const runs = archive.list();
+    if (!runs.length) {
+        throw new CommandError({
+            code: "NO_ARCHIVE",
+            message: "no archived transcripts yet",
+            details: "benchmark runs are archived automatically from now on",
+        });
+    }
+    process.stdout.write(`\n${runs.length} archived run(s), ${(archive.size() / 1024 ** 2).toFixed(1)} MB\n\n`);
+    const execute = options.execute !== false;
+    const stored = results.loadAll();
+    const targets = options.run ? [options.run] : runs;
+    let changed = 0;
+    for (const id of targets) {
+        const result = await rescoreRun(id, { execute });
+        const record = stored.find((r) => r.archiveId === id) ||
+            stored.find((r) => id.includes(results.slugify(r.model.displayName)));
+        process.stdout.write(`  ${id}\n`);
+        for (const task of result.tasks) {
+            if (task.score === null) {
+                process.stdout.write(`    ${task.taskId.padEnd(16)} ${task.summary}\n`);
+                continue;
+            }
+            const before = record?.tasks.find((t) => t.id === task.taskId);
+            const now = `${(task.score * 100).toFixed(0)}%`;
+            const then = before ? `${(before.score * 100).toFixed(0)}%` : "—";
+            const moved = before && Math.abs(before.score - task.score) > 0.005;
+            if (moved)
+                changed += 1;
+            process.stdout.write(`    ${task.taskId.padEnd(16)} was ${then.padStart(5)}  now ${now.padStart(5)}` +
+                `${moved ? "   <- CHANGED" : ""}   ${task.summary}\n`);
+        }
+        process.stdout.write("\n");
+    }
+    process.stdout.write(`  re-graded from stored transcripts, ${changed} task result(s) changed, no GPU used\n\n`);
+}
+//# sourceMappingURL=rescore.js.map

package/dist/commands/runtime.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `otto brain runtime install|list` — manage the self-contained llama.cpp runtime.
+ * `install` downloads a pinned build into $OTTO_HOME/otto-brain/runtimes so the
+ * tool needs no other software; `list` shows every runtime found (managed first,
+ * then LM Studio).
+ */
+import type { Command } from "commander";
+import type { AnyCommandResult } from "../output/index.js";
+export interface RuntimeRow {
+    label: string;
+    version: string;
+    source: string;
+    dir: string;
+}
+export declare function addRuntimeListOptions(cmd: Command): Command;
+export declare function runRuntimeListCommand(_options: unknown, _command: Command): Promise<AnyCommandResult<RuntimeRow>>;
+export declare function addRuntimeInstallOptions(cmd: Command): Command;
+export declare function runRuntimeInstallCommand(options: {
+    build?: string;
+}, _command: Command): Promise<AnyCommandResult<RuntimeRow>>;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/commands/runtime.js

@@ -0,0 +1,62 @@
+import { loadBrainConfig } from "../config/index.js";
+import { resolveBrainPaths } from "../config/paths.js";
+import { defaultRuntimeSpec, installManagedRuntime, listAllRuntimes } from "../runtime/index.js";
+const runtimeSchema = {
+    idField: "dir",
+    columns: [
+        { header: "LABEL", field: "label", width: 20 },
+        { header: "VERSION", field: "version", width: 10 },
+        {
+            header: "SOURCE",
+            field: "source",
+            width: 10,
+            color: (v) => (v === "managed" ? "green" : undefined),
+        },
+        { header: "DIR", field: "dir", width: 50 },
+    ],
+};
+function toRows() {
+    return listAllRuntimes().map((r) => ({
+        label: r.label,
+        version: r.version,
+        source: r.source,
+        dir: r.dir,
+    }));
+}
+export function addRuntimeListOptions(cmd) {
+    return cmd.description("List available llama.cpp runtimes");
+}
+export async function runRuntimeListCommand(_options, _command) {
+    return { type: "list", data: toRows(), schema: runtimeSchema };
+}
+export function addRuntimeInstallOptions(cmd) {
+    return cmd
+        .description("Download a self-contained llama.cpp runtime")
+        .option("--build <tag>", "llama.cpp release build tag");
+}
+export async function runRuntimeInstallCommand(options, _command) {
+    loadBrainConfig();
+    const { runtimesDir } = resolveBrainPaths();
+    const spec = defaultRuntimeSpec(options.build);
+    process.stderr.write(`  installing ${spec.label} (${spec.version})…\n`);
+    const runtime = await installManagedRuntime(spec, runtimesDir, (p) => {
+        if (p.phase === "downloading" && p.totalBytes) {
+            const pct = Math.floor(((p.receivedBytes ?? 0) / p.totalBytes) * 100);
+            process.stderr.write(`  ${pct}%\r`);
+        }
+        if (p.phase === "extracting")
+            process.stderr.write("\n  extracting…\n");
+    });
+    process.stderr.write("\n");
+    return {
+        type: "single",
+        data: {
+            label: runtime.label,
+            version: runtime.version,
+            source: runtime.source,
+            dir: runtime.dir,
+        },
+        schema: runtimeSchema,
+    };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/commands/scan.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `otto brain scan` — list detected models with their arch, quant, size, native
+ * context, vision, calibration state, and source. Returns a typed list the output
+ * layer renders as a table (default), json, or yaml.
+ */
+import type { Command } from "commander";
+import type { AnyCommandResult, OutputSchema } from "../output/index.js";
+export interface ScanRow {
+    model: string;
+    arch: string;
+    quant: string;
+    size: string;
+    ctx: string;
+    vision: string;
+    calibrated: string;
+    features: string;
+    source: string;
+}
+export declare const scanSchema: OutputSchema<ScanRow>;
+export declare function addScanOptions(cmd: Command): Command;
+export declare function runScanCommand(options: {
+    metadata?: boolean;
+}, _command: Command): Promise<AnyCommandResult<ScanRow>>;
+//# sourceMappingURL=scan.d.ts.map

package/dist/commands/scan.js

@@ -0,0 +1,55 @@
+import { getCalibration, forModel, loadBrainConfig, loadProfilesStore } from "../config/index.js";
+import { formatBytes, scanModels } from "../models/index.js";
+export const scanSchema = {
+    idField: "model",
+    columns: [
+        { header: "MODEL", field: "model", width: 40 },
+        { header: "ARCH", field: "arch", width: 10 },
+        { header: "QUANT", field: "quant", width: 8 },
+        { header: "SIZE", field: "size", width: 9, align: "right" },
+        { header: "CTX", field: "ctx", width: 9, align: "right" },
+        { header: "VIS", field: "vision", width: 4 },
+        {
+            header: "CAL",
+            field: "calibrated",
+            width: 4,
+            color: (v) => (v === "yes" ? "green" : undefined),
+        },
+        { header: "FEAT", field: "features", width: 10 },
+        { header: "SOURCE", field: "source", width: 8 },
+    ],
+};
+export function addScanOptions(cmd) {
+    return cmd
+        .description("List detected local models")
+        .option("--no-metadata", "skip reading GGUF headers (faster)");
+}
+export async function runScanCommand(options, _command) {
+    const config = loadBrainConfig();
+    const store = loadProfilesStore();
+    const catalog = scanModels(config, process.env, { withMetadata: options.metadata !== false });
+    const rows = catalog.map((model) => {
+        const profile = forModel(store, model, config.defaults);
+        const md = model.metadata ?? {};
+        const feat = [
+            model.features.mtp ? "MTP" : null,
+            md.reasoning || model.thinking ? "think" : null,
+            model.features.distilled ? "distill" : null,
+        ]
+            .filter(Boolean)
+            .join(",");
+        return {
+            model: model.displayName.slice(0, 45),
+            arch: String(md.arch ?? "-"),
+            quant: model.quant ?? "-",
+            size: formatBytes(model.sizeBytes),
+            ctx: md.contextLength ? String(md.contextLength) : "-",
+            vision: model.mmprojPath ? "yes" : "",
+            calibrated: getCalibration(store, model, profile) ? "yes" : "",
+            features: feat,
+            source: model.origin ?? "-",
+        };
+    });
+    return { type: "list", data: rows, schema: scanSchema };
+}
+//# sourceMappingURL=scan.js.map

package/dist/commands/search.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `otto brain search <query>` and `otto brain repo-quants <repo>` — Hugging Face
+ * model discovery. These wrap the surface-agnostic primitives in models/hf.ts so
+ * the same code serves the TUI (in-process) and the Otto app (daemon shells out
+ * to `--json`, mirroring `catalog`/`scan`).
+ */
+import type { Command } from "commander";
+import type { AnyCommandResult } from "../output/index.js";
+export interface SearchRow {
+    repo: string;
+    downloads: number;
+    likes: number;
+    gated: string;
+    installed: boolean;
+}
+export declare function addSearchOptions(cmd: Command): Command;
+export declare function runSearchCommand(query: string, options: {
+    limit?: string;
+}, _command: Command): Promise<AnyCommandResult<SearchRow>>;
+export interface AddRow {
+    repo: string;
+    quant: string;
+    path: string;
+    size: string;
+}
+export declare function addAddOptions(cmd: Command): Command;
+export declare function runAddCommand(repo: string, options: {
+    quant?: string;
+    listQuants?: boolean;
+}, _command: Command): Promise<AnyCommandResult<AddRow>>;
+//# sourceMappingURL=search.d.ts.map