@2kw/ai 6.1.0-dev.8 → 6.2.0-dev.13

package/dist/commands/conversations.js

@@ -20,6 +20,29 @@ export function makeConversationsCommand() {
             formatDetail(data, command);
         });
     });
+    cmd
+        .command("list")
+        .description("List conversations, most recently active first")
+        .option("--agent-id <id>", "Only conversations bound to this agent")
+        .option("--scope <scope>", "mine (default) or org; org needs MEMBER or above", "mine")
+        .option("--page <n>", "Page number, starting at 0", "0")
+        .option("--size <n>", "Page size, 1 to 100", "30")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/conversations", {
+                params: {
+                    query: {
+                        agent_id: opts.agentId,
+                        scope: opts.scope,
+                        page: Number(opts.page),
+                        size: Number(opts.size),
+                    },
+                },
+            });
+            formatDetail(data, command);
+        });
+    });
     cmd
         .command("get")
         .description("Retrieve a conversation by id")

package/dist/commands/plugins.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+/** Install, sync and detach Claude Code plugins (#640). */
+export declare function makePluginsCommand(): Command;
+//# sourceMappingURL=plugins.d.ts.map

package/dist/commands/plugins.js

@@ -0,0 +1,88 @@
+import { Command, Option } from "commander";
+import { getClient, runAction } from "../lib/client.js";
+import { formatPage, formatDetail, formatSuccess } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+const REF_POLICY_HELP = "track:<branch-or-tag> to follow it, pin:<sha> to freeze";
+/** Install, sync and detach Claude Code plugins (#640). */
+export function makePluginsCommand() {
+    const cmd = new Command("plugins").description("Manage Claude Code plugins imported from git");
+    const list = new Command("list").description("List installed plugins");
+    addPaginationOptions(list);
+    list.addOption(new Option("--status <status>", "Filter by status").choices(["ACTIVE", "DISABLED"]));
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/plugins", {
+                params: { query: { status: opts.status, ...paginationParams(opts) } },
+            });
+            formatPage(data, command, ["id", "name", "gitUrl", "refPolicy", "status", "lastSyncedSha"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get an installed plugin, including its last sync report")
+        .argument("<id>", "Plugin ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/plugins/{id}", { params: { path: { id } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("install")
+        .description("Install a plugin from a git repository and run its first sync (admin)")
+        .argument("<git-url>", "https remote of a repository in Claude Code plugin layout")
+        .option("-n, --name <name>", "Org-local name (default: the manifest name, slugified)")
+        .option("--ref-policy <policy>", REF_POLICY_HELP)
+        .action(async (gitUrl, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/plugins", {
+                body: { gitUrl, name: opts.name, refPolicy: opts.refPolicy },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Change a plugin's ref policy or status (admin)")
+        .argument("<id>", "Plugin ID")
+        .option("--ref-policy <policy>", REF_POLICY_HELP)
+        .addOption(new Option("--status <status>", "ACTIVE or DISABLED").choices(["ACTIVE", "DISABLED"]))
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PATCH("/v1/plugins/{id}", {
+                params: { path: { id } },
+                body: { refPolicy: opts.refPolicy, status: opts.status },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("sync")
+        .description("Sync a plugin now; unchanged is a no-op (admin)")
+        .argument("<id>", "Plugin ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/plugins/{id}/sync", { params: { path: { id } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Detach a plugin; imported skills stay (admin)")
+        .argument("<id>", "Plugin ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/plugins/{id}", { params: { path: { id } } });
+            formatSuccess(`Plugin ${id} detached`, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=plugins.js.map

package/dist/commands/queues.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "commander";
+/**
+ * Annotation queues let a human reviewer work through a curated list of
+ * subjects (run results, traces, spans, dataset items). This command group
+ * covers the queue itself plus the items inside it: creating a queue,
+ * bulk-adding subjects, claiming the next eligible item, and recording the
+ * outcome — the full loop an agent or a human reviewer needs to run review
+ * end to end from the CLI.
+ */
+export declare function makeQueuesCommand(): Command;
+//# sourceMappingURL=queues.d.ts.map

package/dist/commands/queues.js

@@ -0,0 +1,244 @@
+import { Command } from "commander";
+import chalk from "chalk";
+import { getClient, runAction } from "../lib/client.js";
+import { isJsonOutput } from "../lib/config.js";
+import { formatList, formatDetail, formatSuccess } from "../lib/output.js";
+/**
+ * Annotation queues let a human reviewer work through a curated list of
+ * subjects (run results, traces, spans, dataset items). This command group
+ * covers the queue itself plus the items inside it: creating a queue,
+ * bulk-adding subjects, claiming the next eligible item, and recording the
+ * outcome — the full loop an agent or a human reviewer needs to run review
+ * end to end from the CLI.
+ */
+export function makeQueuesCommand() {
+    const cmd = new Command("queues").description("Manage annotation queues for human review");
+    // ── list ──────────────────────────────────────────────────────
+    cmd
+        .command("list")
+        .description("List annotation queues")
+        .option("--archived", "List archived queues instead of active ones", false)
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/annotation-queues", {
+                params: { query: { archived: opts.archived } },
+            });
+            formatList(data, command, [
+                "id",
+                "name",
+                "description",
+                "archivedAt",
+                "createdAt",
+            ]);
+        });
+    });
+    // ── get ───────────────────────────────────────────────────────
+    cmd
+        .command("get")
+        .description("Get an annotation queue by ID")
+        .argument("<id>", "Queue ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/annotation-queues/{id}", {
+                params: { path: { id } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    // ── create ────────────────────────────────────────────────────
+    cmd
+        .command("create")
+        .description("Create a new annotation queue")
+        .requiredOption("-n, --name <name>", "Queue name")
+        .option("-d, --description <text>", "Queue description")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/annotation-queues", {
+                body: { name: opts.name, description: opts.description },
+            });
+            formatDetail(data, command);
+        });
+    });
+    // ── update ────────────────────────────────────────────────────
+    cmd
+        .command("update")
+        .description("Update a queue's name or description")
+        .argument("<id>", "Queue 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 !== undefined)
+                body.name = opts.name;
+            if (opts.description !== undefined)
+                body.description = opts.description;
+            const { data } = await client.PATCH("/v1/annotation-queues/{id}", {
+                params: { path: { id } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    // ── archive ───────────────────────────────────────────────────
+    cmd
+        .command("archive")
+        .description("Archive a queue (idempotent)")
+        .argument("<id>", "Queue ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.POST("/v1/annotation-queues/{id}/archive", {
+                params: { path: { id } },
+            });
+            formatSuccess(`Queue ${id} archived.`, command);
+        });
+    });
+    // ── by-subject ────────────────────────────────────────────────
+    cmd
+        .command("by-subject")
+        .description("Find queue items referencing a subject, across every queue")
+        .requiredOption("--subject-type <type>", "RUN_RESULT | TRACE | SPAN | DATASET_ITEM")
+        .requiredOption("--subject-id <id>", "Subject ID")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/annotation-queues/by-subject", {
+                params: {
+                    query: { subjectType: opts.subjectType, subjectId: opts.subjectId },
+                },
+            });
+            formatList(data, command, [
+                "id",
+                "queueId",
+                "subjectType",
+                "subjectId",
+                "status",
+                "assignedTo",
+            ]);
+        });
+    });
+    // ── next ──────────────────────────────────────────────────────
+    cmd
+        .command("next")
+        .description("Claim the next eligible item in a queue for the caller")
+        .argument("<id>", "Queue ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/annotation-queues/{id}/items/next", {
+                params: { path: { id } },
+            });
+            if (!data) {
+                // 204 No Content: the queue has nothing left for this caller. A
+                // normal end state, not an error — printed plainly either way.
+                if (isJsonOutput(command)) {
+                    console.log(JSON.stringify(null));
+                }
+                else {
+                    console.log(chalk.dim("No items available to claim — the queue is empty for you."));
+                }
+                return;
+            }
+            formatDetail(data, command);
+        });
+    });
+    // ── items ─────────────────────────────────────────────────────
+    const items = new Command("items").description("Manage items within an annotation queue");
+    items
+        .command("list")
+        .description("List items in a queue")
+        .requiredOption("--queue <id>", "Queue ID")
+        .option("--status <status>", "PENDING | IN_PROGRESS | DONE | SKIPPED")
+        .option("--assigned-to <userId>", "Filter by assignee")
+        .option("-p, --page <number>", "Page number (0-indexed)", "0")
+        .option("--size <number>", "Page size", "50")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/annotation-queues/{id}/items", {
+                params: {
+                    path: { id: opts.queue },
+                    query: {
+                        status: opts.status,
+                        assignedTo: opts.assignedTo,
+                        page: opts.page !== undefined ? parseInt(opts.page, 10) : undefined,
+                        size: opts.size !== undefined ? parseInt(opts.size, 10) : undefined,
+                    },
+                },
+            });
+            formatList(data, command, [
+                "id",
+                "subjectType",
+                "subjectId",
+                "status",
+                "assignedTo",
+                "createdAt",
+            ]);
+        });
+    });
+    items
+        .command("add")
+        .description("Bulk-add subjects to a queue (duplicates skipped)")
+        .requiredOption("--queue <id>", "Queue ID")
+        .requiredOption("--items <json>", 'JSON array of {"subjectType","subjectId"} objects')
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const parsedItems = JSON.parse(opts.items);
+            const { data } = await client.POST("/v1/annotation-queues/{id}/items", {
+                params: { path: { id: opts.queue } },
+                body: { items: parsedItems },
+            });
+            formatList(data, command, [
+                "id",
+                "subjectType",
+                "subjectId",
+                "status",
+            ]);
+        });
+    });
+    items
+        .command("get")
+        .description("Get a single queue item")
+        .argument("<itemId>", "Item ID")
+        .requiredOption("--queue <id>", "Queue ID")
+        .action(async (itemId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/annotation-queues/{id}/items/{itemId}", {
+                params: { path: { id: opts.queue, itemId } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    items
+        .command("update")
+        .description("Update a queue item's status or assignee — the outcome of a review")
+        .argument("<itemId>", "Item ID")
+        .requiredOption("--queue <id>", "Queue ID")
+        .option("--status <status>", "PENDING | IN_PROGRESS | DONE | SKIPPED")
+        .option("--assigned-to <userId>", "New assignee")
+        .action(async (itemId, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const body = {};
+            if (opts.status !== undefined)
+                body.status = opts.status;
+            if (opts.assignedTo !== undefined)
+                body.assignedTo = opts.assignedTo;
+            const { data } = await client.PATCH("/v1/annotation-queues/{id}/items/{itemId}", {
+                params: { path: { id: opts.queue, itemId } },
+                body: body,
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd.addCommand(items);
+    return cmd;
+}
+//# sourceMappingURL=queues.js.map

package/dist/commands/scores.js

@@ -1,14 +1,18 @@
 import { Command } from "commander";
 import { getClient, runAction } from "../lib/client.js";
-import { formatDetail } from "../lib/output.js";
+import { formatDetail, formatList } from "../lib/output.js";
 export function makeScoresCommand() {
-    const cmd = new Command("scores").description("Record evaluation scores on experiment run results");
+    const cmd = new Command("scores").description("Record and review evaluation scores on experiment run results and other subjects");
     cmd
         .command("human")
-        .description("Record a human score for a run result. Upserts by (runResultId, evaluatorId, annotatorId).")
-        .requiredOption("--run-result <id>", "Run result ID")
+        .description("Record a human score. Upserts by (subject, evaluatorId, annotatorId) — pass either " +
+        "--run-result, or --subject-type/--subject-id for a trace, span, or dataset item.")
+        .option("--run-result <id>", "Run result ID (legacy shape)")
+        .option("--subject-type <type>", "RUN_RESULT | TRACE | SPAN | DATASET_ITEM")
+        .option("--subject-id <id>", "Subject ID")
+        .option("--queue-item <id>", "Annotation queue item ID this score resolves")
         .requiredOption("--evaluator <id>", "Evaluator identifier (e.g. 'helpfulness' or a template id)")
-        .requiredOption("--score <number>", "Score between 0.0 and 1.0", parseFloat)
+        .option("--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) => {
@@ -17,6 +21,9 @@ export function makeScoresCommand() {
             const { data } = await client.POST("/v1/evaluation-scores/human", {
                 body: {
                     runResultId: opts.runResult,
+                    subjectType: opts.subjectType,
+                    subjectId: opts.subjectId,
+                    annotationQueueItemId: opts.queueItem,
                     evaluatorId: opts.evaluator,
                     score: opts.score,
                     label: opts.label,
@@ -26,6 +33,37 @@ export function makeScoresCommand() {
             formatDetail(data, command);
         });
     });
+    cmd
+        .command("list")
+        .description("List human scores filed against a subject. Defaults to the caller's own scores — " +
+        "pass --annotator to see another reviewer's.")
+        .requiredOption("--subject-type <type>", "RUN_RESULT | TRACE | SPAN | DATASET_ITEM")
+        .requiredOption("--subject-id <id>", "Subject ID")
+        .option("--annotator <id>", "Annotator ID (defaults to the caller)")
+        .action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/evaluation-scores/human", {
+                params: {
+                    query: {
+                        subjectType: opts.subjectType,
+                        subjectId: opts.subjectId,
+                        annotatorId: opts.annotator,
+                    },
+                },
+            });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            formatList(data, command, [
+                "id",
+                "evaluatorId",
+                "score",
+                "label",
+                "annotatorId",
+                "comment",
+                "createdAt",
+            ]);
+        });
+    });
     return cmd;
 }
 //# sourceMappingURL=scores.js.map

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

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+/** Manage skill labels (#642). */
+export declare function makeSkillLabelsCommand(): Command;
+//# sourceMappingURL=skill-labels.d.ts.map

package/dist/commands/skill-labels.js

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

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

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+/** Manage skill versions (#642). */
+export declare function makeSkillVersionsCommand(): Command;
+//# sourceMappingURL=skill-versions.d.ts.map

package/dist/commands/skill-versions.js

@@ -0,0 +1,53 @@
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { getClient, runAction } from "../lib/client.js";
+import { formatPage, formatDetail } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+/** Manage skill versions (#642). */
+export function makeSkillVersionsCommand() {
+    const cmd = new Command("versions").description("Manage skill versions");
+    const list = new Command("list").description("List versions of a skill").argument("<id>", "Skill ID");
+    addPaginationOptions(list);
+    list.action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/skills/{id}/versions", {
+                params: { path: { id }, query: paginationParams(opts) },
+            });
+            formatPage(data, command, ["id", "versionNumber", "description", "contentHash"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a specific skill version")
+        .argument("<id>", "Skill ID")
+        .argument("<versionNumber>", "Version number")
+        .action(async (id, versionNumber, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/skills/{id}/versions/{versionNumber}", {
+                params: { path: { id, versionNumber: Number(versionNumber) } },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a skill version from a markdown body file")
+        .argument("<id>", "Skill ID")
+        .requiredOption("--description <text>", "Version description")
+        .requiredOption("--body-file <path>", "Markdown body file")
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/skills/{id}/versions", {
+                params: { path: { id } },
+                body: { description: opts.description, body: readFileSync(opts.bodyFile, "utf-8") },
+            });
+            formatDetail(data, command);
+        });
+    });
+    return cmd;
+}
+//# sourceMappingURL=skill-versions.js.map

package/dist/commands/skills.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+/** Manage skills, versions and labels (#642). */
+export declare function makeSkillsCommand(): Command;
+//# sourceMappingURL=skills.d.ts.map

package/dist/commands/skills.js

@@ -0,0 +1,161 @@
+import { Command, Option } from "commander";
+import { statSync, writeFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { getClient, resolveAuthHeader, runAction } from "../lib/client.js";
+import { resolveConfig } from "../lib/config.js";
+import { BackboneApiError } from "../lib/errors.js";
+import { fileToBlob } from "../lib/multipart.js";
+import { formatPage, formatDetail, formatSuccess, withSpinner } from "../lib/output.js";
+import { addPaginationOptions, paginationParams } from "../lib/pagination.js";
+import { makeSkillVersionsCommand } from "./skill-versions.js";
+import { makeSkillLabelsCommand } from "./skill-labels.js";
+async function checkResponse(res) {
+    if (res.ok)
+        return;
+    const body = await res.json().catch(() => ({}));
+    throw new BackboneApiError({
+        status: body.status ?? res.status,
+        error: body.title ?? body.error ?? res.statusText,
+        message: body.detail ?? body.message ?? `HTTP ${res.status}: ${res.statusText}`,
+        timestamp: body.timestamp ?? new Date().toISOString(),
+    });
+}
+/** Manage skills, versions and labels (#642). */
+export function makeSkillsCommand() {
+    const cmd = new Command("skills").description("Manage skills");
+    const list = new Command("list").description("List skills");
+    addPaginationOptions(list);
+    list.option("-s, --search <term>", "Filter by name");
+    list.addOption(new Option("--status <status>", "Filter by status").choices(["ACTIVE", "ARCHIVED"]));
+    list.action(async (opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/skills", {
+                params: { query: { search: opts.search, status: opts.status, ...paginationParams(opts) } },
+            });
+            formatPage(data, command, ["id", "name", "status", "latestVersionNumber"]);
+        });
+    });
+    cmd.addCommand(list);
+    cmd
+        .command("get")
+        .description("Get a skill by ID")
+        .argument("<id>", "Skill ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/skills/{id}", { params: { path: { id } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("create")
+        .description("Create a skill (add content with versions create or import)")
+        .argument("<name>", "Skill name")
+        .action(async (name, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.POST("/v1/skills", { body: { name } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("update")
+        .description("Update a skill's status")
+        .argument("<id>", "Skill ID")
+        .addOption(new Option("--status <status>", "New status").choices(["ACTIVE", "ARCHIVED"]).makeOptionMandatory())
+        .action(async (id, opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.PUT("/v1/skills/{id}", {
+                params: { path: { id } },
+                body: { status: opts.status },
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("delete")
+        .description("Delete a skill")
+        .argument("<id>", "Skill ID")
+        .action(async (id, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            await client.DELETE("/v1/skills/{id}", { params: { path: { id } } });
+            formatSuccess(`Skill ${id} deleted.`, command);
+        });
+    });
+    cmd
+        .command("resolve")
+        .description("Resolve a skill by name, name@label or name@version")
+        .argument("<ref>", "Skill reference")
+        .action(async (ref, _opts, command) => {
+        await runAction(command, async () => {
+            const client = getClient(command);
+            const { data } = await client.GET("/v1/skills/resolve", { params: { query: { ref } } });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("import")
+        .description("Import a local SKILL.md or zip archive")
+        .argument("<path>", "Local SKILL.md or .zip file")
+        .action(async (path, _opts, command) => {
+        await runAction(command, async () => {
+            if (statSync(path).isDirectory())
+                throw new Error("Cannot import a directory; zip it first.");
+            if (basename(path) !== "SKILL.md" && extname(path).toLowerCase() !== ".zip") {
+                throw new Error("Import requires a SKILL.md or .zip file.");
+            }
+            const config = resolveConfig(command);
+            const authHeader = await resolveAuthHeader(config);
+            const { blob, filename } = fileToBlob(path);
+            const formData = new FormData();
+            formData.append("file", blob, filename);
+            const data = await withSpinner("Importing skill...", async () => {
+                const res = await fetch(`${config.baseUrl.replace(/\/+$/, "")}/v1/skills/import`, {
+                    method: "POST",
+                    headers: { Authorization: authHeader },
+                    body: formData,
+                });
+                await checkResponse(res);
+                return res.json();
+            });
+            formatDetail(data, command);
+        });
+    });
+    cmd
+        .command("export")
+        .description("Export a skill version as a zip archive")
+        .argument("<id>", "Skill ID")
+        .argument("<versionNumber>", "Version number")
+        .option("-o, --output <file>", "Output path (default: <skill-name>-v<n>.zip)")
+        .action(async (id, versionNumber, opts, command) => {
+        await runAction(command, async () => {
+            let outputPath = opts.output;
+            if (!outputPath) {
+                const client = getClient(command);
+                const { data } = await client.GET("/v1/skills/{id}", { params: { path: { id } } });
+                if (!data?.name)
+                    throw new Error("Skill name missing; specify an output path with -o.");
+                outputPath = `${basename(data.name)}-v${versionNumber}.zip`;
+            }
+            const config = resolveConfig(command);
+            const authHeader = await resolveAuthHeader(config);
+            const bytes = await withSpinner("Exporting skill...", async () => {
+                const baseUrl = config.baseUrl.replace(/\/+$/, "");
+                const res = await fetch(`${baseUrl}/v1/skills/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionNumber)}/export`, {
+                    headers: { Authorization: authHeader },
+                });
+                await checkResponse(res);
+                return Buffer.from(await res.arrayBuffer());
+            });
+            writeFileSync(outputPath, bytes);
+            formatSuccess(`Wrote ${bytes.length} bytes to ${outputPath}`, command);
+        });
+    });
+    cmd.addCommand(makeSkillVersionsCommand());
+    cmd.addCommand(makeSkillLabelsCommand());
+    return cmd;
+}
+//# sourceMappingURL=skills.js.map

package/dist/index.js

@@ -7,6 +7,8 @@ const pkg = require("../package.json");
 import { makeConfigCommand } from "./commands/config.js";
 import { makeSchemasCommand } from "./commands/schemas.js";
 import { makePromptsCommand } from "./commands/prompts.js";
+import { makeSkillsCommand } from "./commands/skills.js";
+import { makePluginsCommand } from "./commands/plugins.js";
 import { makeExtractionsCommand } from "./commands/extractions.js";
 import { makeConvertCommand } from "./commands/convert.js";
 import { makeAiCommand } from "./commands/ai.js";
@@ -21,6 +23,7 @@ import { makeExperimentsCommand } from "./commands/experiments.js";
 import { makeTracingCommand } from "./commands/tracing.js";
 import { makeEvaluatorsCommand } from "./commands/evaluators.js";
 import { makeScoresCommand } from "./commands/scores.js";
+import { makeQueuesCommand } from "./commands/queues.js";
 import { makeAgentsCommand } from "./commands/agents.js";
 import { makeConversationsCommand } from "./commands/conversations.js";
 import { makeKnowledgeCommand } from "./commands/knowledge.js";
@@ -42,6 +45,8 @@ program.addCommand(makeConfigCommand());
 program.addCommand(makeContextCommand());
 program.addCommand(makeSchemasCommand());
 program.addCommand(makePromptsCommand());
+program.addCommand(makeSkillsCommand());
+program.addCommand(makePluginsCommand());
 program.addCommand(makeExtractionsCommand());
 program.addCommand(makeConvertCommand());
 program.addCommand(makeAiCommand());
@@ -53,6 +58,7 @@ program.addCommand(makeDatasetsCommand());
 program.addCommand(makeExperimentsCommand());
 program.addCommand(makeEvaluatorsCommand());
 program.addCommand(makeScoresCommand());
+program.addCommand(makeQueuesCommand());
 program.addCommand(makeTracingCommand());
 program.addCommand(makeAgentsCommand());
 program.addCommand(makeConversationsCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2kw/ai",
-  "version": "6.1.0-dev.8",
+  "version": "6.2.0-dev.13",
   "description": "CLI for 2kw.ai — schema-driven document extraction, an OpenAI-compatible EU LLM gateway, transcription, prompts, datasets, and experiments from your terminal or agentic workflows. Ships as 2kw, backbone, and bb.",
   "keywords": [
     "cli",
@@ -54,7 +54,7 @@
     "ora": "^8.2.0"
   },
   "devDependencies": {
-    "@types/node": "^22.19.17",
+    "@types/node": "^22.20.1",
     "openapi-typescript": "^7.13.0",
     "tsx": "^4.21.1",
     "typescript": "^5.9.3",