@thinkingai/ae-cli 6.1.17 → 6.1.19

package/dist/{te-kb-SQCLHG6X.js → te-kb-BUD6N3NI.js}

@@ -1,17 +1,23 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   kbApi,
   kbUpload
-} from "./chunk-4KVPKXFX.js";
+} from "./chunk-JYMGHGCE.js";
 import {
   printError
-} from "./chunk-GT46FPXN.js";
-import "./chunk-4SGZG4XY.js";
-import "./chunk-ZZUOD757.js";
+} from "./chunk-KEWVSO64.js";
 import {
+  CapabilityGatewayError
+} from "./chunk-GJXRF7Y6.js";
+import "./chunk-Y74WTIKJ.js";
+import "./chunk-RWXIXOZG.js";
+import "./chunk-O6K2ODUE.js";
+import "./chunk-KZ6ZHF5J.js";
+import {
+  CliValidationError,
   PermissionError
-} from "./chunk-UW5UN47B.js";
-import "./chunk-LYVNONC4.js";
-import "./chunk-QGM4M3NI.js";
+} from "./chunk-533JK3YX.js";
+import "./chunk-FR2EDAQM.js";
 
 // src/commands/te-kb/add.ts
 import { promises as fs } from "fs";
@@ -375,27 +381,41 @@ var create = {
 
 // src/commands/te-kb/rm-source.ts
 var API_PATH5 = "/agent/api/external/knowledge-bases/sources";
+function sourceSelector(ctx) {
+  const id = ctx.str("id").trim();
+  if (id) return { id };
+  const displayName = ctx.str("display-name").trim();
+  if (displayName) return { displayName };
+  throw new CliValidationError("One of --id or --display-name is required.");
+}
 function buildBody4(ctx) {
   return {
     name: ctx.str("name"),
-    displayName: ctx.str("display-name")
+    ...sourceSelector(ctx)
   };
 }
 var rmSource = {
   service: "kb",
   command: "+rm-source",
-  description: "Delete a single source file inside a knowledge.",
+  description: "Delete one source from a knowledge base by ID or exact display name.",
   flags: [
     { name: "name", type: "string", required: true, desc: "Knowledge base name (looked up personal \u2192 company)" },
-    { name: "display-name", type: "string", required: true, desc: "Source file display name as uploaded (e.g. kb-1780046712-foo.md)" }
+    { name: "id", type: "string", required: false, desc: "Source ID copied from +list-sources (preferred)" },
+    { name: "display-name", type: "string", required: false, desc: "Exact source display name for legacy compatibility" }
   ],
-  risk: "write",
+  risk: "high-risk-write",
+  validate: (ctx) => {
+    sourceSelector(ctx);
+  },
   dryRun: (ctx) => ({
     method: "DELETE",
     url: `${ctx.host().replace(/\/$/, "")}${API_PATH5}`,
     body: buildBody4(ctx)
   }),
-  execute: async (ctx) => kbApi(ctx, "DELETE", API_PATH5, {}, buildBody4(ctx))
+  execute: async (ctx) => kbApi(ctx, "DELETE", API_PATH5, {}, buildBody4(ctx), {
+    preserveErrorMetadata: true,
+    retryUnauthorized: true
+  })
 };
 
 // src/commands/te-kb/schema.ts
@@ -407,8 +427,15 @@ function buildBody5(ctx) {
   if (ctx.bool("force")) body.force = true;
   const model = ctx.str("model");
   if (model) body.model = model;
+  const customInstructions = ctx.str("custom-instructions");
+  if (customInstructions) body.customInstructions = customInstructions;
   return body;
 }
+async function executeSchema(ctx, api = kbApi) {
+  return api(ctx, "POST", API_PATH6, {}, buildBody5(ctx), {
+    preserveBusinessErrorCode: true
+  });
+}
 var schema = {
   service: "kb",
   command: "+schema",
@@ -416,7 +443,14 @@ var schema = {
   flags: [
     { name: "name", type: "string", required: true, desc: "Knowledge base name (looked up personal \u2192 company)" },
     { name: "force", type: "boolean", required: false, desc: "Preempt generation even when status is `generating` (use only for stuck recovery)" },
-    { name: "model", type: "string", required: false, desc: "Optional model displayName to use for schema generation" }
+    { name: "model", type: "string", required: false, desc: "Optional model displayName to use for schema generation" },
+    {
+      name: "custom-instructions",
+      type: "string",
+      required: false,
+      sensitive: true,
+      desc: "Optional per-run instructions for generating this knowledge base schema"
+    }
   ],
   risk: "write",
   dryRun: (ctx) => ({
@@ -424,7 +458,7 @@ var schema = {
     url: `${ctx.host().replace(/\/$/, "")}${API_PATH6}`,
     body: buildBody5(ctx)
   }),
-  execute: async (ctx) => kbApi(ctx, "POST", API_PATH6, {}, buildBody5(ctx))
+  execute: executeSchema
 };
 
 // src/commands/te-kb/status.ts
@@ -533,8 +567,59 @@ var kbList = {
   execute: async (ctx) => kbApi(ctx, "POST", API_PATH9, {}, buildBody8(ctx))
 };
 
+// src/commands/te-kb/list-sources.ts
+var API_PATH10 = "/agent/api/external/knowledge-bases/sources";
+var MAX_KNOWLEDGE_BASE_NAME_LENGTH = 200;
+function knowledgeBaseName(ctx) {
+  return ctx.str("name").trim();
+}
+function buildUrl(ctx) {
+  const url2 = new URL(`${ctx.host().replace(/\/$/, "")}${API_PATH10}`);
+  url2.searchParams.set("name", knowledgeBaseName(ctx));
+  return url2.toString();
+}
+var listSources = {
+  service: "kb",
+  command: "+list-sources",
+  description: "List source metadata for a knowledge base via GET /agent/api/external/knowledge-bases/sources?name=<name>. Copy the stable source ID from this output before using +rm-source.",
+  flags: [
+    {
+      name: "name",
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: MAX_KNOWLEDGE_BASE_NAME_LENGTH,
+      desc: "Knowledge base name"
+    }
+  ],
+  risk: "read",
+  validate: (ctx) => {
+    const name = knowledgeBaseName(ctx);
+    if (!name) {
+      throw new CliValidationError("Invalid --name: must be non-empty.");
+    }
+    if (name.length > MAX_KNOWLEDGE_BASE_NAME_LENGTH) {
+      throw new CliValidationError(
+        `Invalid --name length: ${name.length}. Must be at most ${MAX_KNOWLEDGE_BASE_NAME_LENGTH} characters.`
+      );
+    }
+  },
+  dryRun: (ctx) => ({
+    method: "GET",
+    url: buildUrl(ctx)
+  }),
+  execute: async (ctx) => kbApi(
+    ctx,
+    "GET",
+    API_PATH10,
+    { name: knowledgeBaseName(ctx) },
+    void 0,
+    { preserveErrorMetadata: true, retryUnauthorized: true }
+  )
+};
+
 // src/commands/te-kb/kb-grep.ts
-var API_PATH10 = "/agent/api/external/knowledge-bases/grep";
+var API_PATH11 = "/agent/api/external/knowledge-bases/grep";
 function buildBody9(ctx) {
   const body = {
     query: ctx.str("query"),
@@ -577,14 +662,14 @@ var kbGrep = {
   risk: "read",
   dryRun: (ctx) => ({
     method: "POST",
-    url: `${ctx.host().replace(/\/$/, "")}${API_PATH10}`,
+    url: `${ctx.host().replace(/\/$/, "")}${API_PATH11}`,
     body: buildBody9(ctx)
   }),
-  execute: async (ctx) => kbApi(ctx, "POST", API_PATH10, {}, buildBody9(ctx))
+  execute: async (ctx) => kbApi(ctx, "POST", API_PATH11, {}, buildBody9(ctx))
 };
 
 // src/commands/te-kb/kb-read.ts
-var API_PATH11 = "/agent/api/external/knowledge-bases/read";
+var API_PATH12 = "/agent/api/external/knowledge-bases/read";
 function buildBody10(ctx) {
   const body = {
     source: ctx.json("source"),
@@ -629,10 +714,10 @@ var kbRead = {
   risk: "read",
   dryRun: (ctx) => ({
     method: "POST",
-    url: `${ctx.host().replace(/\/$/, "")}${API_PATH11}`,
+    url: `${ctx.host().replace(/\/$/, "")}${API_PATH12}`,
     body: buildBody10(ctx)
   }),
-  execute: async (ctx) => kbApi(ctx, "POST", API_PATH11, {}, buildBody10(ctx))
+  execute: async (ctx) => kbApi(ctx, "POST", API_PATH12, {}, buildBody10(ctx))
 };
 
 // src/commands/te-kb/ask-shared.ts
@@ -859,7 +944,7 @@ var askStatus = {
 };
 
 // src/commands/te-kb/url.ts
-var API_PATH12 = "/agent/api/external/knowledge-bases/sources/url";
+var API_PATH13 = "/agent/api/external/knowledge-bases/sources/url";
 function validateUrl(url2) {
   if (!/^https?:\/\//i.test(url2)) {
     throw new Error(`Invalid --url: ${url2}. Must be an http(s) URL`);
@@ -884,7 +969,7 @@ var url = {
     { name: "name", type: "string", required: true, desc: "Knowledge base name" },
     { name: "url", type: "string", required: true, desc: "Source URL to upload" },
     { name: "display-name", type: "string", required: false, desc: "Optional display name for the URL source" },
-    { name: "parse-instruction", type: "string", required: false, desc: "Optional parsing instruction for the URL source" }
+    { name: "parse-instruction", type: "string", required: false, desc: "Optional parsing instruction for the URL source; ignored for Lark/Feishu doc URLs (the server applies its own Feishu parsing)" }
   ],
   risk: "write",
   validate: (ctx) => {
@@ -892,10 +977,206 @@ var url = {
   },
   dryRun: (ctx) => ({
     method: "POST",
-    url: `${ctx.host().replace(/\/$/, "")}${API_PATH12}`,
+    url: `${ctx.host().replace(/\/$/, "")}${API_PATH13}`,
     body: buildBody12(ctx)
   }),
-  execute: async (ctx) => kbApi(ctx, "POST", API_PATH12, {}, buildBody12(ctx))
+  execute: async (ctx) => kbApi(ctx, "POST", API_PATH13, {}, buildBody12(ctx))
+};
+
+// src/commands/te-kb/import.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var API_PATH14 = "/agent/api/external/knowledge-bases/import";
+var MAX_SNAPSHOT_ARCHIVE_BYTES = 50 * 1024 * 1024;
+function normalizeTags2(raw) {
+  if (raw === void 0 || raw === null) return [];
+  if (!Array.isArray(raw)) {
+    throw new Error(
+      `--tags must be a JSON array of strings, e.g. '["docs","product"]'`
+    );
+  }
+  const tags = [];
+  for (const value of raw) {
+    if (typeof value !== "string") {
+      throw new Error(
+        `--tags entries must be strings (got: ${JSON.stringify(value)})`
+      );
+    }
+    const tag = value.trim();
+    if (tag && !tags.includes(tag)) tags.push(tag);
+  }
+  if (tags.length > 2) throw new Error("--tags accepts at most 2 unique tags");
+  if (tags.some((tag) => tag.length > 15)) {
+    throw new Error("--tags entries must be at most 15 characters");
+  }
+  return tags;
+}
+function validateArchivePath(filePath) {
+  if (path2.extname(filePath).toLocaleLowerCase("en-US") !== ".zip") {
+    throw new Error("--file must point to a .zip archive");
+  }
+}
+async function readArchive(filePath) {
+  validateArchivePath(filePath);
+  const absolutePath = path2.resolve(filePath);
+  let stat;
+  try {
+    stat = await fs2.stat(absolutePath);
+  } catch {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  if (!stat.isFile())
+    throw new Error(`--file must point to a file: ${filePath}`);
+  if (stat.size === 0) throw new Error(`ZIP archive is empty: ${filePath}`);
+  if (stat.size > MAX_SNAPSHOT_ARCHIVE_BYTES) {
+    throw new Error("--file must not exceed 50 MB");
+  }
+  return { absolutePath, bytes: await fs2.readFile(absolutePath) };
+}
+function appendOptionalFields(ctx, form) {
+  const description = ctx.str("description").trim();
+  if (description) form.append("description", description);
+  for (const tag of normalizeTags2(ctx.json("tags"))) form.append("tags", tag);
+  const projectId = ctx.str("project-id").trim();
+  if (projectId) form.append("projectId", projectId);
+}
+var importSnapshot = {
+  service: "kb",
+  command: "+import",
+  description: "Import a compiled Markdown ZIP snapshot as a personal read-only knowledge base.",
+  flags: [
+    {
+      name: "file",
+      type: "string",
+      required: true,
+      desc: "Local .zip snapshot containing root index.md and wiki/**/*.md"
+    },
+    {
+      name: "name",
+      type: "string",
+      required: true,
+      maxLength: 30,
+      desc: "Personal knowledge base name (max 30 characters)"
+    },
+    {
+      name: "description",
+      type: "string",
+      required: false,
+      maxLength: 200,
+      desc: "Optional description (max 200 characters)"
+    },
+    {
+      name: "tags",
+      type: "json",
+      required: false,
+      desc: "Optional JSON array of tags (max 2, each max 15 characters)"
+    },
+    {
+      name: "project-id",
+      type: "string",
+      required: false,
+      maxLength: 128,
+      desc: "Optional project ID to bind"
+    }
+  ],
+  risk: "write",
+  validate: (ctx) => {
+    validateArchivePath(ctx.str("file"));
+    normalizeTags2(ctx.json("tags"));
+  },
+  execute: async (ctx) => {
+    const archive = await readArchive(ctx.str("file"));
+    const form = new FormData();
+    form.append(
+      "file",
+      new Blob([Uint8Array.from(archive.bytes)], { type: "application/zip" }),
+      path2.basename(archive.absolutePath)
+    );
+    form.append("name", ctx.str("name").trim());
+    appendOptionalFields(ctx, form);
+    try {
+      return await kbUpload(
+        ctx,
+        API_PATH14,
+        form,
+        {},
+        { preserveErrorMetadata: true, retryUnauthorized: true }
+      );
+    } catch (error) {
+      const hint = "If a requestId was returned, run ae-cli kb +import-status --request-id <requestId>; otherwise run ae-cli kb +list before retrying the same name.";
+      if (error instanceof CapabilityGatewayError) {
+        throw new CapabilityGatewayError(
+          `${error.message} ${hint}`,
+          error.code,
+          error.httpStatus,
+          error.hint ?? hint,
+          error.meta
+        );
+      }
+      if (error instanceof Error) {
+        error.message = `${error.message} ${hint}`;
+        throw error;
+      }
+      throw new Error(`${String(error)} ${hint}`);
+    }
+  }
+};
+
+// src/commands/te-kb/import-status.ts
+var API_PATH15 = "/agent/api/external/knowledge-bases/import";
+var MAX_REQUEST_ID_LENGTH = 191;
+function requestIdFrom(ctx) {
+  return ctx.str("request-id").trim();
+}
+var importStatus = {
+  service: "kb",
+  command: "+import-status",
+  description: "Query one asynchronous knowledge-base snapshot import by its request ID without polling.",
+  flags: [
+    {
+      name: "request-id",
+      type: "string",
+      required: true,
+      minLength: 1,
+      maxLength: MAX_REQUEST_ID_LENGTH,
+      desc: "The requestId returned by kb +import."
+    }
+  ],
+  risk: "read",
+  validate: (ctx) => {
+    const requestId = requestIdFrom(ctx);
+    if (!requestId) throw new Error("Invalid --request-id: must be non-empty.");
+    if (requestId.length > MAX_REQUEST_ID_LENGTH) {
+      throw new Error(
+        `Invalid --request-id length: ${requestId.length}. Must be at most ${MAX_REQUEST_ID_LENGTH} characters.`
+      );
+    }
+  },
+  dryRun: (ctx) => ({
+    method: "GET",
+    url: `${ctx.host().replace(/\/$/, "")}${API_PATH15}?requestId=${encodeURIComponent(requestIdFrom(ctx))}`
+  }),
+  execute: async (ctx) => {
+    try {
+      return await kbApi(
+        ctx,
+        "GET",
+        API_PATH15,
+        { requestId: requestIdFrom(ctx) },
+        void 0,
+        { preserveErrorMetadata: true, retryUnauthorized: true }
+      );
+    } catch (error) {
+      if (!(error instanceof CapabilityGatewayError) || error.hint) throw error;
+      throw new CapabilityGatewayError(
+        error.message,
+        error.code,
+        error.httpStatus,
+        "Verify the request ID and that the server supports kb +import-status. Do not retry the import until its status is known.",
+        error.meta
+      );
+    }
+  }
 };
 
 // src/commands/te-kb/index.ts
@@ -907,13 +1188,16 @@ var commands = [
   compile,
   remove,
   create,
+  listSources,
   rmSource,
   schema,
   status,
   kbList,
   kbIndex,
   kbGrep,
-  kbRead
+  kbRead,
+  importSnapshot,
+  importStatus
 ];
 var te_kb_default = commands;
 export {
@@ -923,10 +1207,13 @@ export {
   compile,
   create,
   te_kb_default as default,
+  importSnapshot,
+  importStatus,
   kbGrep,
   kbIndex,
   kbList,
   kbRead,
+  listSources,
   remove,
   rmSource,
   schema,