@wirecat/cli-core 0.409.0 → 0.411.0

package/dist/cli/model-catalogue-command.js

@@ -0,0 +1,110 @@
+import { join } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { annotate } from "@wirecat/cli-base/commands";
+import { defineQuery } from "@wirecat/cli-base/query";
+import { Command } from "commander";
+import { isTextModelInstalled, textModelsDirectory } from "../embeddings/embed.js";
+import { DEFAULT_TEXT_MODEL, TEXT_MODELS } from "../embeddings/models.js";
+import { downloadTextModel } from "../services/model-downloads.js";
+import { install, installedBytes, isInstalled, modelsDirectory } from "../speech/install.js";
+import { DEFAULT_ORDER, orderedModels, speechModel } from "../speech/models.js";
+import { FETCH, LOCAL_READ, NO_EFFECTS } from "./effects.js";
+import { itemOf, listOf } from "./envelope.js";
+import { listQuery, nativeTerms, termField, typedQuery, withQuery } from "./list-query.js";
+export const MODEL_CATALOGUE_QUERY = defineQuery({
+    entity: "model",
+    backend: "native",
+    fields: [
+        termField("kind", "enum", "kind:audio", { values: ["audio", "text"] }),
+        termField("id", "kw", "id:e5-small"),
+        termField("downloaded", "bool", "downloaded:true"),
+    ],
+});
+/** Provider composition supplies I/O and supported kinds; parsing, receipts and download policy stay shared. */
+export const modelCatalogueCommand = (app, options) => {
+    if (options.kinds.length === 0)
+        throw new CliError("configuration_error", "declare at least one supported model kind");
+    const audio = (id, env) => {
+        const model = speechModel(id);
+        const directory = modelsDirectory(env);
+        return {
+            id,
+            kind: "audio",
+            title: model.title,
+            languages: model.languages,
+            size_bytes: installedBytes(model),
+            downloaded: isInstalled(model, directory),
+            default: id === (options.defaultAudio?.() ?? DEFAULT_ORDER[0]),
+            path: join(directory, id),
+        };
+    };
+    const text = (id, env) => {
+        const model = TEXT_MODELS.find((one) => one.id === id);
+        if (!model)
+            throw new CliError("validation_error", `unknown text model ${id}`);
+        const directory = textModelsDirectory(env);
+        return {
+            id,
+            kind: "text",
+            title: model.title,
+            languages: model.languages,
+            licence: model.licence,
+            size_bytes: model.files.reduce((sum, file) => sum + file.bytes, 0),
+            downloaded: isTextModelInstalled(model, directory),
+            default: id === DEFAULT_TEXT_MODEL,
+            path: join(directory, id),
+        };
+    };
+    const models = annotate(new Command("models"), { effects: NO_EFFECTS }).description("models that run on this machine");
+    withQuery(annotate(models.command("list"), {
+        effects: LOCAL_READ,
+        output: { entity: "model" },
+        examples: [`${app.command} models list`, `${app.command} models list kind:${options.kinds[0]}`],
+    }), MODEL_CATALOGUE_QUERY)
+        .description("speech and embedding models, their download status and the default of each kind")
+        .action(function (words) {
+        const terms = nativeTerms(listQuery(typedQuery(words), MODEL_CATALOGUE_QUERY, "models list"), "models list");
+        const env = options.env();
+        const items = [
+            ...(options.kinds.includes("audio") ? orderedModels().map((model) => audio(model.id, env)) : []),
+            ...(options.kinds.includes("text") ? TEXT_MODELS.map((model) => text(model.id, env)) : []),
+        ].filter((item) => (terms.get("kind") === undefined || item.kind === terms.get("kind")?.value) &&
+            (terms.get("id") === undefined || item.id === terms.get("id")?.value) &&
+            (terms.get("downloaded") === undefined || item.downloaded === (terms.get("downloaded")?.value === "true")));
+        options.output(listOf("models list", { items, limit: Math.max(1, items.length), has_more: false }), this);
+    });
+    annotate(models.command("download"), {
+        effects: FETCH,
+        output: { entity: "model" },
+        examples: [
+            `${app.command} models download ${options.kinds.includes("text") ? DEFAULT_TEXT_MODEL : DEFAULT_ORDER[0]}`,
+        ],
+    })
+        .description("download and verify one speech or embedding model")
+        .argument("<model>", "a model id from models list")
+        .option("--offline", "refuse a download that needs the network")
+        .option("--accept-terms", "accept the model's licence terms, for a model that has its own")
+        .action(async function (id, given) {
+        if (options.offline?.() || this.optsWithGlobals().offline)
+            throw new CliError("permission_error", "downloading a model needs the network; --offline was requested", {
+                reason: "model.offline",
+            });
+        const env = options.env();
+        if (TEXT_MODELS.some((model) => model.id === id)) {
+            if (!options.kinds.includes("text"))
+                throw new CliError("validation_error", "this tool does not use text models");
+            await downloadTextModel(id, { env, acceptTerms: given.acceptTerms === true, progress: options.diagnostic });
+            options.output(itemOf(text(id, env)), this);
+        }
+        else {
+            if (!options.kinds.includes("audio"))
+                throw new CliError("validation_error", "this tool does not use audio models");
+            await install(speechModel(id), modelsDirectory(env), { verifyExisting: true, progress: options.diagnostic });
+            options.output(itemOf(audio(id, env)), this);
+        }
+    });
+    if (options.jsonOption)
+        for (const command of models.commands)
+            command.option("--json", "print JSON");
+    return models;
+};

package/dist/cli/program.js

@@ -30,6 +30,7 @@ import { PreviewComplete, preview } from "./preview.js";
 import { commandWords, liftProfile, PROFILE_FREE, valuedOptions } from "./profile.js";
 import { absolutePaths, relayTarget } from "./relay-route.js";
 import { settingsFor } from "./settings.js";
+import { assertSharedContracts } from "./shared-contracts.js";
 import { commandAt, lineOf, withLines } from "./steps.js";
 /**
  * The command tree, built fresh on each call. Commander is global state by default —
@@ -66,6 +67,7 @@ export const createProgram = ({ app, commands, configure, firstScreen }, { out,
     for (const command of commands())
         program.addCommand(command);
     configure?.(program);
+    assertSharedContracts(program);
     installHelp(program, { pitch: app.description, ...firstScreen });
     // Commander builds a usage line from the command tree, where the profile is not a word.
     for (const top of program.commands) {

package/dist/cli/runs/search-command.js

@@ -12,7 +12,6 @@ import { RUN_SEARCH_QUERY, runSearchFilter } from "./search-query.js";
 export const runsSearchCommand = (app) => annotate(withQuery(new Command("runs")
     .summary("search recorded diagnostic metadata and events")
     .description("search recorded diagnostic metadata and events; literal words and field:value terms joined by AND; no message contents")
-    .option("--since-time <time>", "runs starting on or after an ISO time or 2h / 1d ago")
     .option("--limit <n>", "matches per page, at most 100", positiveCount("--limit"), 20)
     .option("--page <n>", "result page", positiveCount("--page"), 1), RUN_SEARCH_QUERY), {
     effects: LOCAL_READ,
@@ -22,6 +21,6 @@ export const runsSearchCommand = (app) => annotate(withQuery(new Command("runs")
     const filter = runSearchFilter(words);
     const options = this.opts();
     const dir = runsDirFor(app, environmentOf(this).env ?? process.env);
-    const found = searchRuns(dir, { ...filter, ...options, since: options.sinceTime });
-    renderAnswer(this, outputFor(this), runsFound(found, { query: typedQuery(words), since_time: options.sinceTime }));
+    const found = searchRuns(dir, { ...filter, ...options });
+    renderAnswer(this, outputFor(this), runsFound(found, { query: typedQuery(words) }));
 });

package/dist/cli/runs/search-query.d.ts

@@ -1,4 +1,4 @@
 import { type QueryWords } from "../list-query.js";
 import type { RunSearch } from "./search.js";
 export declare const RUN_SEARCH_QUERY: import("@wirecat/cli-base/query").QueryRegistry;
-export declare const runSearchFilter: (words: QueryWords) => Pick<RunSearch, "terms" | "status" | "errorCode" | "operation" | "profile">;
+export declare const runSearchFilter: (words: QueryWords) => Pick<RunSearch, "terms" | "status" | "errorCode" | "operation" | "profile" | "since" | "until">;

package/dist/cli/runs/search-query.js

@@ -1,9 +1,15 @@
-import { defineQuery, parseLucene, queryError, validateQuery } from "@wirecat/cli-base/query";
-import { LIST_QUERY_GUIDE, termField, typedQuery } from "../list-query.js";
+import { defineQuery, parseLucene, queryError, validateQuery, } from "@wirecat/cli-base/query";
+import { LIST_QUERY_GUIDE, nativeField, termField, timeBounds, typedQuery } from "../list-query.js";
 export const RUN_SEARCH_QUERY = defineQuery({
     entity: "run",
     backend: "native",
     fields: [
+        nativeField({
+            name: "started_at",
+            type: "time",
+            operators: ["term", "phrase", "range"],
+            example: "started_at>=7d",
+        }),
         termField("text", "kw", "text:timeout"),
         termField("status", "enum", "status:failed", { values: ["success", "failed", "partial", "running"] }),
         termField("error_code", "kw", "error_code:rate_limited"),
@@ -20,6 +26,7 @@ export const runSearchFilter = (words) => {
     validateQuery(ast, RUN_SEARCH_QUERY, context);
     const terms = [];
     const fields = new Map();
+    let started;
     const add = (node) => {
         if (node.kind === "boolean") {
             for (const clause of node.clauses) {
@@ -29,6 +36,12 @@ export const runSearchFilter = (words) => {
             }
             return;
         }
+        if (node.field === "started_at") {
+            if (started)
+                queryError("query.unsupported-placement", node.span, "started_at only once here; use a range", context);
+            started = node;
+            return;
+        }
         if (node.operator !== "term" && node.operator !== "phrase")
             queryError("query.unsupported-placement", node.span, "run search takes literal words and field:value terms", context);
         if (node.field === "text")
@@ -40,7 +53,10 @@ export const runSearchFilter = (words) => {
         }
     };
     add(ast.root);
+    const window = timeBounds(started);
     return {
+        ...(window.since === undefined ? {} : { since: new Date(window.since).toISOString() }),
+        ...(window.until === undefined ? {} : { until: new Date(window.until).toISOString() }),
         ...(terms.length ? { terms } : {}),
         ...(fields.has("status") ? { status: fields.get("status")?.toLowerCase() } : {}),
         ...(fields.has("error_code") ? { errorCode: fields.get("error_code") } : {}),

package/dist/cli/runs/search.d.ts

@@ -6,10 +6,11 @@ export interface RunSearch {
     operation?: string;
     profile?: string;
     since?: string;
+    until?: string;
     limit?: number;
     page?: number;
 }
-export declare const searchRuns: (dir: string, { query, terms, status, errorCode, operation, profile, since, limit, page }?: RunSearch) => {
+export declare const searchRuns: (dir: string, { query, terms, status, errorCode, operation, profile, since, until, limit, page }?: RunSearch) => {
     items: {
         runId: string;
         command: string;

package/dist/cli/runs/search.js

@@ -32,10 +32,10 @@ const safeEvent = (event) => Object.fromEntries(FIELDS.flatMap((name) => {
     }
     return typeof value === "string" || typeof value === "number" ? [[name, value]] : [];
 }));
-export const searchRuns = (dir, { query = "", terms = [], status, errorCode, operation, profile, since, limit = 20, page = 1 } = {}) => {
+export const searchRuns = (dir, { query = "", terms = [], status, errorCode, operation, profile, since, until, limit = 20, page = 1 } = {}) => {
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(page) || page < 1)
         throw new CliError("validation_error", "run search uses a limit from 1 to 100 and a positive page");
-    const window = dateWindow(since === undefined ? {} : { sinceTime: since });
+    const window = dateWindow({ sinceTime: since, untilTime: until });
     const from = window.since;
     if (from !== undefined && !Number.isFinite(from))
         throw new CliError("validation_error", "--since-time must be a valid date or ISO timestamp");
@@ -45,7 +45,8 @@ export const searchRuns = (dir, { query = "", terms = [], status, errorCode, ope
     for (const run of listRuns(dir, from === undefined ? {} : { since: from })) {
         if ((profile !== undefined && run.profile !== profile) ||
             (status !== undefined && run.status !== status) ||
-            (from !== undefined && Date.parse(run.startedAt) < from))
+            (from !== undefined && Date.parse(run.startedAt) < from) ||
+            (window.until !== undefined && Date.parse(run.startedAt) > window.until))
             continue;
         const metadataMatch = (!errorCode ||
             run.errorCode === errorCode ||