@vatio-ai/cli 0.43.0 → 0.45.0

package/lib/commands/knowledge.mjs

@@ -22,7 +22,7 @@ export async function kb(config, args) {
   switch (sub) {
     case "list": return await list(client, workspace);
     case "show": return await show(client, workspace, args.shift());
-    case "create": return await create(client, workspace, args.shift());
+    case "create": return await create(client, workspace, args.splice(0));
     case "rm": return await remove(client, workspace, args.shift());
     case "write": return await write(client, workspace, args);
     case "cat": return await cat(client, args.shift(), args.shift());
@@ -38,7 +38,7 @@ function usage() {
   return `usage:
   vatio kb                                  List knowledge bases
   vatio kb show NAME                        One base: its sites and its entries
-  vatio kb create NAME                      Create a base
+  vatio kb create NAME [NAME...]            Create one base, or several
   vatio kb rm NAME                          Delete a base (must be unreferenced)
   vatio kb write BASE ENTRY [FILE]          Write an entry, from FILE or stdin
   vatio kb cat BASE ENTRY                   Print an entry's markdown
@@ -110,13 +110,30 @@ async function show(client, workspace, name) {
   }
 }
 
-async function create(client, workspace, name) {
-  if (!name) fail("usage: vatio kb create NAME");
+// Several names, because the moment this command is most often run is a push
+// that just refused for naming bases that do not exist yet -- and that push
+// names all of them at once. One base per invocation turned a first deploy
+// into one round trip per name.
+//
+// Still never implicit: a base is created because someone typed its name here,
+// which is what keeps `knowledge: [defualt]` a failed push instead of an empty
+// base the agent searches forever.
+async function create(client, workspace, names) {
+  const wanted = names.filter((name) => name.trim() !== "");
+  if (wanted.length === 0) fail("usage: vatio kb create NAME [NAME...]");
+
+  const created = [];
+  for (const name of wanted) {
+    const base = await client.createKnowledgeBase(name);
+    created.push(base.name);
+    console.log(`Created knowledge base ${base.name} on workspace ${workspace}`);
+  }
 
-  const base = await client.createKnowledgeBase(name);
-  console.log(`Created knowledge base ${base.name} on workspace ${workspace}`);
-  console.log("It is empty and nothing reads it yet. Fill it with `vatio kb write` or `vatio kb follow`,");
-  console.log(`then add \`knowledge: [${base.name}]\` to vatio.yml and push.`);
+  console.log(created.length === 1
+    ? "It is empty and nothing reads it yet."
+    : "They are empty and nothing reads them yet.");
+  console.log("Fill with `vatio kb write` or `vatio kb follow`, then add");
+  console.log(`\`knowledge: [${created.join(", ")}]\` to the agent in vatio.yml and push.`);
 }
 
 async function remove(client, workspace, name) {

package/lib/commands/support-commands.mjs

@@ -4,9 +4,11 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 
+import { buildBundle } from "../bundle.mjs";
 import { HttpClient } from "../http.mjs";
 import { VERSION } from "../version.mjs";
 import { fail, takeFlag, takeValue } from "../support.mjs";
+import { findWorkspaceRoot } from "../workspace.mjs";
 import { DOCS_URL } from "./misc.mjs";
 
 // The whole developer contract as markdown, live from the platform. Fetched
@@ -50,6 +52,9 @@ function issuesClient(config) {
 // `vatio issue` is a change worth making, written against a template the
 // platform also validates against. It is not an issue tracker: there are no
 // states, labels, assignees or backlog, and that is on purpose.
+//
+// Sent from a workspace, it carries the workspace -- see workspaceSource
+// below, and `--no-source` to send the sentence alone.
 export async function issue(config, args) {
   const sub = args[0];
   if (sub === "list") return await issueList(config);
@@ -58,6 +63,7 @@ export async function issue(config, args) {
 
   if (takeFlag(args, "--template")) return await issueTemplate(config);
 
+  const withoutSource = takeFlag(args, "--no-source");
   const file = takeValue(args, "--file");
   const workspace = takeValue(args, "--workspace") ?? safeWorkspace(config);
 
@@ -67,6 +73,14 @@ export async function issue(config, args) {
 
   const body = { cli_version: VERSION };
   if (workspace) body.workspace = workspace;
+
+  const source = withoutSource ? null : workspaceSource();
+  if (source?.files) {
+    body.files = source.files;
+    console.log(`Attaching ${source.root} — ${source.files.length} files, the same ones \`vatio push\` sends.`);
+  } else if (source?.error) {
+    console.log(`Not attaching your workspace: ${source.error}`);
+  }
   if (file) {
     body.markdown = readFileSync(file, "utf8");
   } else {
@@ -75,7 +89,8 @@ export async function issue(config, args) {
       fail(
         "Usage: vatio issue \"what should change\"\n" +
           "       vatio issue --file ISSUE.md\n" +
-          "       vatio issue --template   # the shape it is read against"
+          "       vatio issue --template    # the shape it is read against\n" +
+          "       vatio issue --no-source   # without your workspace attached"
       );
     }
     body.message = message;
@@ -96,18 +111,42 @@ async function issueTemplate(config) {
   process.stdout.write(await response.text());
 }
 
+// Where a report stands, in the words the developer is actually asking in:
+// has anyone looked at it, and is the ball with them or with us. There is no
+// `status` field to print -- an issue has no states -- so this reads the few
+// facts the platform does publish about the thread.
+function issueStatus(row) {
+  if (row.resolved) return "closed";
+  // The developer wrote last and nothing has gone back yet.
+  if (row.awaiting_us) return "with us";
+  if (row.answered) return "answered";
+  if (row.answers > 0) return "in progress";
+  return "sent";
+}
+
 async function issueList(config) {
+  // `data`, the same envelope every other read in this CLI unwraps. Reading
+  // `issues` here is how `list` spent its whole life reporting that a
+  // developer had sent nothing while `show` returned those same issues by id.
   const payload = await issuesClient(config).get("/cli/issues");
-  const issues = Array.isArray(payload.issues) ? payload.issues : [];
+  const issues = Array.isArray(payload.data) ? payload.data : [];
   if (issues.length === 0) {
     console.log("You have not sent any issues yet.");
     console.log('  Send one: vatio issue "what should change"');
     return;
   }
   console.log(`Your issues (${issues.length}):`);
+  const idWidth = Math.max(...issues.map((row) => String(row.id).length));
+  const statusWidth = Math.max(...issues.map((row) => issueStatus(row).length));
+  // The pull request goes under the title it belongs to, so the id and status
+  // columns stay readable as columns.
+  const indent = " ".repeat(2 + idWidth + 3 + statusWidth + 2);
   for (const row of issues) {
-    console.log(`  [${row.id}] ${row.status ?? ""}  ${row.title ?? row.summary ?? ""}`.trimEnd());
+    const id = `[${String(row.id).padStart(idWidth)}]`;
+    console.log(`  ${id} ${issueStatus(row).padEnd(statusWidth)}  ${row.title ?? ""}`.trimEnd());
+    if (row.pull_request_url) console.log(`${indent}${row.pull_request_url}`);
   }
+  console.log("Read one, conversation included: vatio issue show ID");
 }
 
 // The markdown view, which is the same document Vatio's own triage agent
@@ -136,6 +175,24 @@ async function issueComment(config, id, rest) {
   console.log(`Replied on issue ${id}.`);
 }
 
+// The directory the issue was typed in, sent whole -- the same bundle `check`
+// and `push` send, because which files matter is the platform's contract and
+// this client does not get a second answer to it.
+//
+// Nothing here can stop an issue from being sent: a directory that is not a
+// workspace, or one too large to bundle, travels without its source. The call
+// site says so out loud, since a developer is entitled to know what left their
+// machine, and `--no-source` declines in advance.
+function workspaceSource() {
+  try {
+    const root = findWorkspaceRoot(process.cwd());
+    if (!root) return null;
+    return { root, files: buildBundle(root) };
+  } catch (error) {
+    return { error: error.message };
+  }
+}
+
 // A workspace is useful context on an issue but never required: `vatio issue`
 // has to work from anywhere, including a directory that is not a workspace.
 function safeWorkspace(config) {

package/lib/help.mjs

@@ -61,6 +61,7 @@ flag, the directory decides.
 
   Everything else:
     issue "what should change"|list|show ID|comment ID "reply"|--template
+                               Sends your workspace along; --no-source to not
     mcp                        Speak MCP over stdio, for a coding agent
     config show|get KEY|set KEY VALUE|unset KEY
                                Keys: base_url, token

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vatio-ai/cli",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "description": "Vatio CLI — deploy and manage Vatio agent workspaces",
   "keywords": ["vatio", "agent", "ai", "cli", "deploy"],
   "homepage": "https://vatio.ai",