@2kw/ai 4.0.0-dev.2

package/dist/commands/prompts.js

@@ -0,0 +1,159 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { makePromptVersionsCommand } from "./prompt-versions.js";
+import { makePromptLabelsCommand } from "./prompt-labels.js";
+export function makePromptsCommand() {
+    const cmd = new Command("prompts").description("Manage prompts");
+    const list = new Command("list").description("List prompts");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.option("--type <type>", "Filter by type");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/prompts", {
+                params: {
+                    query: { search: opts.search, type: opts.type, ...paginationParams(opts) },
+                },
+            });
+            formatPage(data, command, ["id", "name", "type", "description", "activeVersionId", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a prompt by ID")
+        .argument("<id>", "Prompt ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/prompts/{id}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new prompt")
+        .requiredOption("-n, --name <name>", "Prompt name")
+        .option("-d, --description <text>", "Prompt description")
+        .option("--type <type>", "Prompt type (TEXT or CHAT)", "TEXT")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/prompts", {
+                body: { name: opts.name, description: opts.description, type: opts.type },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a prompt")
+        .argument("<id>", "Prompt ID")
+        .option("-n, --name <name>", "New name")
+        .option("-d, --description <text>", "New description")
+        .option("--type <type>", "New type")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            if (opts.type !== undefined)
+                body.type = opts.type;
+            const { data } = await client.PUT("/v1/prompts/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a prompt")
+        .argument("<id>", "Prompt ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/prompts/{id}", {
+                params: { path: { id } },
+            });
+            formatSuccess(`Prompt ${id} deleted.`, command);
+        });
+    });
+    cmd
+        .command("resolve")
+        .description("Resolve prompt content (latest or by label)")
+        .argument("<promptId>", "Prompt ID")
+        .option("-l, --label <name>", "Label to resolve")
+        .action(async (promptId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/prompts/{promptId}/resolve", {
+                params: {
+                    path: { promptId },
+                    query: { label: opts.label },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("compile")
+        .description("Compile a prompt with variable substitution")
+        .argument("<promptId>", "Prompt ID")
+        .option("--vars <json>", "Variables as JSON object")
+        .option("--version-id <id>", "Specific version ID")
+        .option("-l, --label <name>", "Label to use")
+        .action(async (promptId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const variables = opts.vars ? JSON.parse(opts.vars) : undefined;
+            const { data } = await client.POST("/v1/prompts/{promptId}/compile", {
+                params: { path: { promptId } },
+                body: {
+                    variables,
+                    versionId: opts.versionId,
+                    label: opts.label,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("test")
+        .description("Test a prompt with an LLM")
+        .argument("<promptId>", "Prompt ID")
+        .requiredOption("-m, --model <model>", "Model to use (provider/model)")
+        .option("-t, --text <text>", "Input text")
+        .option("--vars <json>", "Variables as JSON object")
+        .option("--version-id <id>", "Specific version ID")
+        .option("-l, --label <name>", "Label to use")
+        .action(async (promptId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const variables = opts.vars ? JSON.parse(opts.vars) : undefined;
+            const { data } = await client.POST("/v1/prompts/{promptId}/test", {
+                params: { path: { promptId } },
+                body: {
+                    model: opts.model,
+                    content: opts.text,
+                    variables,
+                    versionId: opts.versionId,
+                    label: opts.label,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(makePromptVersionsCommand());
+    cmd.addCommand(makePromptLabelsCommand());
+    return cmd;
+}
+//# sourceMappingURL=prompts.js.map

package/dist/commands/providers.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeProvidersCommand(): Command;
+//# sourceMappingURL=providers.d.ts.map

package/dist/commands/providers.js

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { formatPage, formatDetail, formatList, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+export function makeProvidersCommand() {
+    const cmd = new Command("providers").description("Manage AI providers");
+    const list = new Command("list").description("List providers");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers", {
+                params: { query: { search: opts.search, ...paginationParams(opts) } },
+            });
+            formatPage(data, command, ["id", "name", "type", "enabled", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a provider by ID")
+        .argument("<id>", "Provider ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers/{id}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new provider")
+        .requiredOption("-n, --name <name>", "Provider name")
+        .requiredOption("--type <type>", "Provider type (openai, azure_openai, anthropic, xai, mistral, vertex_ai, ollama)")
+        .requiredOption("--provider-api-key <key>", "API key for the AI provider")
+        .option("-c, --config <json>", "Provider config as JSON")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const config = opts.config ? JSON.parse(opts.config) : {};
+            const { data } = await client.POST("/v1/providers", {
+                body: { name: opts.name, provider: opts.type.toUpperCase(), apiKey: opts.providerApiKey, config },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a provider")
+        .argument("<id>", "Provider ID")
+        .option("-n, --name <name>", "New name")
+        .option("--type <type>", "New type")
+        .option("--enabled <bool>", "Enable/disable")
+        .option("-c, --config <json>", "New config as JSON")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.type)
+                body.provider = opts.type.toUpperCase();
+            if (opts.enabled !== undefined)
+                body.enabled = opts.enabled === "true";
+            if (opts.config)
+                body.config = JSON.parse(opts.config);
+            const { data } = await client.PATCH("/v1/providers/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a provider")
+        .argument("<id>", "Provider ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/providers/{id}", {
+                params: { path: { id } },
+            });
+            formatSuccess(`Provider ${id} deleted.`, command);
+        });
+    });
+    cmd
+        .command("models")
+        .description("List available models across all providers")
+        .action(async (_opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/providers/models");
+            const json = isJsonOutput(command);
+            if (json) {
+                console.log(JSON.stringify(data, null, 2));
+            }
+            else {
+                const models = data?.data ?? [];
+                formatList(models, command, [
+                    "id",
+                    "provider",
+                    "name",
+                    "capabilities",
+                ]);
+            }
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=providers.js.map

package/dist/commands/schema-labels.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeSchemaLabelsCommand(): Command;
+//# sourceMappingURL=schema-labels.d.ts.map

package/dist/commands/schema-labels.js

@@ -0,0 +1,67 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatList, formatDetail, formatSuccess } from "../lib/output.js";
+export function makeSchemaLabelsCommand() {
+    const cmd = new Command("labels").description("Manage schema labels");
+    cmd
+        .command("list")
+        .description("List labels for a schema")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/schemas/{schemaId}/labels", { params: { path: { schemaId: opts.schema } } });
+            formatList(data, command, [
+                "name",
+                "schemaVersionId",
+                "createdAt",
+            ]);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a label for a schema version")
+        .requiredOption("--schema <id>", "Schema ID")
+        .requiredOption("-n, --name <name>", "Label name")
+        .requiredOption("--version-id <id>", "Schema version ID to label")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/schemas/{schemaId}/labels", {
+                params: { path: { schemaId: opts.schema } },
+                body: { name: opts.name, schemaVersionId: opts.versionId },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a label to point to a different version")
+        .argument("<labelName>", "Label name")
+        .requiredOption("--schema <id>", "Schema ID")
+        .requiredOption("--version-id <id>", "New schema version ID")
+        .action(async (labelName, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/schemas/{schemaId}/labels/{labelName}", {
+                params: { path: { schemaId: opts.schema, labelName } },
+                body: { schemaVersionId: opts.versionId },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a schema label")
+        .argument("<labelName>", "Label name")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (labelName, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/schemas/{schemaId}/labels/{labelName}", { params: { path: { schemaId: opts.schema, labelName } } });
+            formatSuccess(`Label "${labelName}" deleted.`, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=schema-labels.js.map

package/dist/commands/schema-versions.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeSchemaVersionsCommand(): Command;
+//# sourceMappingURL=schema-versions.d.ts.map

package/dist/commands/schema-versions.js

@@ -0,0 +1,66 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatPage, formatDetail } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+export function makeSchemaVersionsCommand() {
+    const cmd = new Command("versions").description("Manage schema versions");
+    const list = new Command("list").description("List versions of a schema");
+    addPaginationOptions(list);
+    list.requiredOption("--schema <id>", "Schema ID");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/schemas/{schemaId}/versions", {
+                params: {
+                    path: { schemaId: opts.schema },
+                    query: paginationParams(opts),
+                },
+            });
+            formatPage(data, command, ["id", "version", "active", "changeDescription", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a specific schema version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/schemas/{schemaId}/versions/{versionId}", { params: { path: { schemaId: opts.schema, versionId } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new schema version")
+        .requiredOption("--schema <id>", "Schema ID")
+        .requiredOption("-c, --content <json>", "JSON Schema content")
+        .option("-m, --message <text>", "Change description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const content = JSON.parse(opts.content);
+            const { data } = await client.POST("/v1/schemas/{schemaId}/versions", {
+                params: { path: { schemaId: opts.schema } },
+                body: { jsonSchema: content, changeDescription: opts.message },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("activate")
+        .description("Activate a schema version")
+        .argument("<versionId>", "Version ID")
+        .requiredOption("--schema <id>", "Schema ID")
+        .action(async (versionId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/schemas/{schemaId}/versions/{versionId}/activate", { params: { path: { schemaId: opts.schema, versionId } } });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=schema-versions.js.map

package/dist/commands/schemas.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeSchemasCommand(): Command;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/commands/schemas.js

@@ -0,0 +1,178 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { ensureOpenAiCompatible } from "../lib/schema-compat.js";
+import { makeSchemaVersionsCommand } from "./schema-versions.js";
+import { makeSchemaLabelsCommand } from "./schema-labels.js";
+export function makeSchemasCommand() {
+    const cmd = new Command("schemas").description("Manage schemas");
+    const list = new Command("list").description("List schemas");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/schemas", {
+                params: {
+                    query: { search: opts.search, ...paginationParams(opts) },
+                },
+            });
+            formatPage(data, command, ["id", "name", "description", "activeVersionId", "createdAt"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a schema by ID")
+        .argument("<id>", "Schema ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/schemas/{id}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a new schema")
+        .requiredOption("-n, --name <name>", "Schema name")
+        .option("-d, --description <text>", "Schema description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/schemas", {
+                body: { name: opts.name, description: opts.description },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a schema")
+        .argument("<id>", "Schema ID")
+        .option("-n, --name <name>", "New name")
+        .option("-d, --description <text>", "New description")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.name)
+                body.name = opts.name;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            const { data } = await client.PUT("/v1/schemas/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a schema")
+        .argument("<id>", "Schema ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/schemas/{id}", {
+                params: { path: { id } },
+            });
+            formatSuccess(`Schema ${id} deleted.`, command);
+        });
+    });
+    cmd
+        .command("validate")
+        .description("Validate a JSON schema without saving")
+        .argument("<schemaId>", "Schema ID")
+        .requiredOption("-c, --content <json>", "JSON Schema content")
+        .action(async (schemaId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const content = JSON.parse(opts.content);
+            const { data } = await client.POST("/v1/schemas/{schemaId}/validate", {
+                params: { path: { schemaId } },
+                body: { jsonSchema: content },
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = data;
+            if (isJsonOutput(command)) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result?.valid) {
+                formatSuccess("Schema is valid.", command);
+                if (result.warnings?.length) {
+                    console.log(`Warnings: ${result.warnings.join(", ")}`);
+                }
+            }
+            else {
+                console.error("Schema is invalid:");
+                for (const err of result?.errors ?? [])
+                    console.error(`  - ${err}`);
+            }
+        });
+    });
+    cmd
+        .command("test")
+        .description("Test a schema with sample text")
+        .argument("<schemaId>", "Schema ID")
+        .requiredOption("-t, --text <text>", "Sample text to extract from")
+        .requiredOption("-m, --model <model>", "Model to use (provider/model)")
+        .option("-c, --content <json>", "JSON Schema content (overrides stored version)")
+        .option("-l, --label <name>", "Schema label to resolve")
+        .action(async (schemaId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            let jsonSchema;
+            if (opts.content) {
+                jsonSchema = JSON.parse(opts.content);
+            }
+            else {
+                // Resolve the schema content from the active version (or by label)
+                const { data: resolved } = await client.GET("/v1/schemas/{schemaId}/resolve", {
+                    params: {
+                        path: { schemaId },
+                        query: { label: opts.label },
+                    },
+                });
+                jsonSchema = resolved?.jsonSchema;
+                if (!jsonSchema) {
+                    throw new Error("No active schema version found. Create a version first or pass --content.");
+                }
+            }
+            const { data } = await client.POST("/v1/schemas/{schemaId}/test", {
+                params: { path: { schemaId } },
+                body: {
+                    jsonSchema: ensureOpenAiCompatible(jsonSchema),
+                    sampleText: opts.text,
+                    model: opts.model,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("resolve")
+        .description("Resolve schema content (latest or by label)")
+        .argument("<schemaId>", "Schema ID")
+        .option("-l, --label <name>", "Label to resolve")
+        .action(async (schemaId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/schemas/{schemaId}/resolve", {
+                params: {
+                    path: { schemaId },
+                    query: { label: opts.label },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(makeSchemaVersionsCommand());
+    cmd.addCommand(makeSchemaLabelsCommand());
+    return cmd;
+}
+//# sourceMappingURL=schemas.js.map

package/dist/commands/scores.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeScoresCommand(): Command;
+//# sourceMappingURL=scores.d.ts.map

package/dist/commands/scores.js

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatDetail } from "../lib/output.js";
+export function makeScoresCommand() {
+    const cmd = new Command("scores").description("Record evaluation scores on experiment run results");
+    cmd
+        .command("human")
+        .description("Record a human score for a run result. Upserts by (runResultId, evaluatorId, annotatorId).")
+        .requiredOption("--run-result <id>", "Run result ID")
+        .requiredOption("--evaluator <id>", "Evaluator identifier (e.g. 'helpfulness' or a template id)")
+        .requiredOption("--score <number>", "Score between 0.0 and 1.0", parseFloat)
+        .option("--label <text>", "Short label (e.g. 'pass', 'fail', 'good')")
+        .option("--comment <text>", "Optional reviewer note")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/evaluation-scores/human", {
+                body: {
+                    runResultId: opts.runResult,
+                    evaluatorId: opts.evaluator,
+                    score: opts.score,
+                    label: opts.label,
+                    comment: opts.comment,
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=scores.js.map

package/dist/commands/tracing.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function makeTracingCommand(): Command;
+//# sourceMappingURL=tracing.d.ts.map