@deployxai/dxc 0.2.5 → 0.3.0

package/dist/chunks/{knowledge-YPR7JKUT.js → knowledge-JCYMCMSP.js}

@@ -9,11 +9,9 @@ import {
   LocalStateError,
   contentKnowledgeImportResultSchema,
   contentKnowledgeModelSchema,
-  contentKnowledgeQuoteInitResultSchema,
   contentKnowledgeQuoteListResultSchema,
   contentKnowledgeQuoteMutationResultSchema,
   contentKnowledgeQuoteStatusResultSchema,
-  contentKnowledgeQuoteSyncResultSchema,
   contentKnowledgeRemoveResultSchema,
   contentKnowledgeSearchModeSchema,
   contentKnowledgeSearchResultSchema,
@@ -25,7 +23,7 @@ import {
   resolveUserPath,
   writePrivateBuffer,
   writePrivateJson
-} from "./chunk-JB5USZ4F.js";
+} from "./chunk-6JNQZHAQ.js";
 
 // apps/cli/src/knowledge.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
@@ -351,12 +349,14 @@ var MAXIMUM_DIRECTORY_ARTICLES = 1e3;
 var MAXIMUM_DIRECTORY_DEPTH = 32;
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 var KnowledgeCliError = class extends Error {
-  constructor(code, message) {
+  constructor(code, message, details) {
     super(message);
     this.code = code;
+    this.details = details;
     this.name = "KnowledgeCliError";
   }
   code;
+  details;
 };
 var quoteMetadataValueSchema = z.string().trim().min(1).max(300).refine((value) => !/[\r\n]/u.test(value) && value !== "\uFF08\u65E0\uFF09", {
   message: "quote metadata must stay on one line"
@@ -426,6 +426,39 @@ function skippedArticle(error, inputPath) {
 function sha2562(value) {
   return createHash2("sha256").update(value).digest("hex");
 }
+function knowledgeModelChoices(operation, inputFingerprint) {
+  const choiceId = (mode) => {
+    const payload = Buffer.from(
+      JSON.stringify({ inputFingerprint, mode, operation, version: 1 }),
+      "utf8"
+    ).toString("base64url");
+    return `knowledge-choice1_${payload}.${sha2562(payload).slice(0, 32)}`;
+  };
+  return {
+    choices: [
+      { choiceId: choiceId("retry-semantic"), label: "\u91CD\u8BD5\u672C\u5730\u8BED\u4E49\u6A21\u578B" },
+      { choiceId: choiceId("lexical"), label: "\u672C\u6B21\u4EC5\u4F7F\u7528\u5173\u952E\u8BCD" }
+    ],
+    purpose: "knowledge-model-unavailable",
+    type: "select-choice"
+  };
+}
+function selectedKnowledgeMode(action, choiceId) {
+  if (choiceId === void 0) {
+    return "default";
+  }
+  const selected = action.choices.find((choice) => choice.choiceId === choiceId);
+  if (selected === void 0) {
+    throw new KnowledgeCliError(
+      "DXC_KNOWLEDGE_QUERY_INVALID",
+      "Knowledge choice does not belong to the current operation"
+    );
+  }
+  return selected.label === "\u672C\u6B21\u4EC5\u4F7F\u7528\u5173\u952E\u8BCD" ? "lexical" : "retry-semantic";
+}
+function knowledgeModelUnavailable(message, action, code) {
+  return new KnowledgeCliError(code, message, { nextAction: action });
+}
 function normalizedMarkdown(value) {
   return value.replaceAll("\r\n", "\n").replaceAll("\r", "\n").trim();
 }
@@ -1787,44 +1820,65 @@ var KnowledgeCli = class {
       lexicalOnly
     });
   }
-  async initQuotes() {
+  async importSource(source, lexicalOnly, choiceId) {
+    const target = resolveUserPath({
+      currentDirectory: this.#currentDirectory,
+      homeDirectory: this.#homeDirectory,
+      input: source
+    });
+    let metadata;
+    try {
+      metadata = await lstat(target);
+    } catch {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_INPUT_NOT_FOUND",
+        "Knowledge import source was not found"
+      );
+    }
+    if (metadata.isSymbolicLink()) {
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_INPUT_NOT_FOUND",
+        "Knowledge import source must not be a symbolic link"
+      );
+    }
+    const action = knowledgeModelChoices("import", sha2562(target));
+    const selectedMode = selectedKnowledgeMode(action, choiceId);
+    const effectiveLexicalOnly = selectedMode === "lexical" || selectedMode === "default" && lexicalOnly;
+    try {
+      if (metadata.isDirectory()) {
+        return await this.importDirectory(target, effectiveLexicalOnly);
+      }
+      if (metadata.isFile()) {
+        return await this.importArticles({ files: [target], lexicalOnly: effectiveLexicalOnly });
+      }
+      throw new KnowledgeCliError(
+        "DXC_KNOWLEDGE_INPUT_NOT_FOUND",
+        "Knowledge import source must be a file or directory"
+      );
+    } catch (error) {
+      if (error instanceof KnowledgeCliError && error.code === "DXC_KNOWLEDGE_MODEL_FAILED" && !effectiveLexicalOnly) {
+        throw knowledgeModelUnavailable(error.message, action, error.code);
+      }
+      throw error;
+    }
+  }
+  async #initQuotes() {
     const sourcePath = quoteSourcePath(this.#homeDirectory);
     const exists = await quoteSourceExists(sourcePath);
     if (!exists) {
       const legacyPath = legacyQuoteSourcePath(this.#homeDirectory);
       const legacyExists = await quoteSourceExists(legacyPath);
-      const quotes = legacyExists ? (await readQuoteSource(legacyPath, true)).quotes : [
-        {
-          quoteId: this.#randomUUID(),
-          status: "active",
-          text: "\u628A\u8FD9\u53E5\u66FF\u6362\u6210\u4F60\u81EA\u5DF1\u7684\u91D1\u53E5\uFF1B\u91D1\u53E5 ID \u4E00\u65E6\u521B\u5EFA\u5C31\u4E0D\u8981\u4FEE\u6539\u3002",
-          tags: ["\u793A\u4F8B"],
-          source: "\u4E2A\u4EBA\u539F\u521B",
-          origin: "original",
-          attribution: null,
-          verbatimUse: "original"
-        }
-      ];
+      const quotes = legacyExists ? (await readQuoteSource(legacyPath, true)).quotes : [];
       await writeQuoteSource(sourcePath, quotes);
     }
-    const database = await openDatabase(this.#databasePath);
-    try {
-      return contentKnowledgeQuoteInitResultSchema.parse({
-        command: "knowledge.quotes.init",
-        data: { ...quoteSourceSummary(database, true), created: !exists },
-        ok: true
-      });
-    } finally {
-      database.close();
-    }
+    await this.#syncQuotes(true);
   }
   async listQuotes() {
     const sourcePath = quoteSourcePath(this.#homeDirectory);
     if (!await quoteSourceExists(sourcePath)) {
-      throw new KnowledgeCliError(
-        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
-        "Quote source file is not initialized; run knowledge quotes init first"
-      );
+      await this.#initQuotes();
+    } else {
+      await this.#syncQuotes(true);
     }
     const source = await readQuoteSource(sourcePath);
     return contentKnowledgeQuoteListResultSchema.parse({
@@ -1836,12 +1890,20 @@ var KnowledgeCli = class {
   async addQuote(options) {
     const sourcePath = quoteSourcePath(this.#homeDirectory);
     if (!await quoteSourceExists(sourcePath)) {
-      throw new KnowledgeCliError(
-        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
-        "Quote source file is not initialized; run knowledge quotes init first"
-      );
+      await this.#initQuotes();
     }
     const source = await readQuoteSource(sourcePath);
+    const duplicate = source.quotes.find(
+      (item) => item.status === "active" && item.text.trim() === options.text.trim()
+    );
+    if (duplicate !== void 0) {
+      await this.#syncQuotes(false);
+      return contentKnowledgeQuoteMutationResultSchema.parse({
+        command: "knowledge.quotes.add",
+        data: { quote: quoteRecord(duplicate), synced: true },
+        ok: true
+      });
+    }
     const quote = quoteSourceItemSchema.safeParse({
       attribution: options.attribution ?? null,
       origin: options.origin ?? "original",
@@ -1855,10 +1917,17 @@ var KnowledgeCli = class {
     if (!quote.success) {
       throw new KnowledgeCliError("DXC_KNOWLEDGE_QUOTE_INVALID", "Quote input is invalid");
     }
-    await writeQuoteSource(sourcePath, [...source.quotes, quote.data]);
+    const nextQuotes = [...source.quotes, quote.data];
+    await writeQuoteSource(sourcePath, nextQuotes);
+    try {
+      await this.#syncQuotes(false);
+    } catch (error) {
+      await writeQuoteSource(sourcePath, source.quotes);
+      throw error;
+    }
     return contentKnowledgeQuoteMutationResultSchema.parse({
       command: "knowledge.quotes.add",
-      data: { pendingSync: true, quote: quoteRecord(quote.data) },
+      data: { quote: quoteRecord(quote.data), synced: true },
       ok: true
     });
   }
@@ -1868,10 +1937,7 @@ var KnowledgeCli = class {
     }
     const sourcePath = quoteSourcePath(this.#homeDirectory);
     if (!await quoteSourceExists(sourcePath)) {
-      throw new KnowledgeCliError(
-        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
-        "Quote source file is not initialized; run knowledge quotes init first"
-      );
+      await this.#initQuotes();
     }
     const source = await readQuoteSource(sourcePath);
     const index = source.quotes.findIndex((quote) => quote.quoteId === quoteId);
@@ -1899,9 +1965,15 @@ var KnowledgeCli = class {
     const quotes = source.quotes.map(sourceQuote);
     quotes[index] = updated.data;
     await writeQuoteSource(sourcePath, quotes);
+    try {
+      await this.#syncQuotes(false);
+    } catch (error) {
+      await writeQuoteSource(sourcePath, source.quotes);
+      throw error;
+    }
     return contentKnowledgeQuoteMutationResultSchema.parse({
       command: "knowledge.quotes.update",
-      data: { pendingSync: true, quote: quoteRecord(updated.data) },
+      data: { quote: quoteRecord(updated.data), synced: true },
       ok: true
     });
   }
@@ -1911,10 +1983,7 @@ var KnowledgeCli = class {
     }
     const sourcePath = quoteSourcePath(this.#homeDirectory);
     if (!await quoteSourceExists(sourcePath)) {
-      throw new KnowledgeCliError(
-        "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
-        "Quote source file is not initialized; run knowledge quotes init first"
-      );
+      await this.#initQuotes();
     }
     const source = await readQuoteSource(sourcePath);
     const index = source.quotes.findIndex((quote) => quote.quoteId === quoteId);
@@ -1932,9 +2001,15 @@ var KnowledgeCli = class {
     const quotes = source.quotes.map(sourceQuote);
     quotes[index] = archived;
     await writeQuoteSource(sourcePath, quotes);
+    try {
+      await this.#syncQuotes(false);
+    } catch (error) {
+      await writeQuoteSource(sourcePath, source.quotes);
+      throw error;
+    }
     return contentKnowledgeQuoteMutationResultSchema.parse({
       command: "knowledge.quotes.archive",
-      data: { pendingSync: true, quote: quoteRecord(archived) },
+      data: { quote: quoteRecord(archived), synced: true },
       ok: true
     });
   }
@@ -1964,12 +2039,12 @@ var KnowledgeCli = class {
       database.close();
     }
   }
-  async syncQuotes(lexicalOnly) {
+  async #syncQuotes(lexicalOnly) {
     const sourcePath = quoteSourcePath(this.#homeDirectory);
     if (!await quoteSourceExists(sourcePath)) {
       throw new KnowledgeCliError(
         "DXC_KNOWLEDGE_QUOTE_SOURCE_NOT_INITIALIZED",
-        "Quote source file is not initialized; run knowledge quotes init first"
+        "Quote source file is not initialized"
       );
     }
     if (!lexicalOnly) {
@@ -1996,7 +2071,7 @@ var KnowledgeCli = class {
           }
         }
       }
-      const status = syncQuotes(
+      syncQuotes(
         database,
         source.quotes,
         source.contentSha256,
@@ -2004,15 +2079,6 @@ var KnowledgeCli = class {
         this.#now().toISOString(),
         unchanged
       );
-      return contentKnowledgeQuoteSyncResultSchema.parse({
-        command: "knowledge.quotes.sync",
-        data: {
-          ...quoteSourceSummary(database, true),
-          model: lexicalOnly ? null : this.#embedder.model,
-          status
-        },
-        ok: true
-      });
     } finally {
       database.close();
     }
@@ -2057,9 +2123,16 @@ var KnowledgeCli = class {
       database.close();
     }
   }
-  async search(queryInput, modeInput, limitInput) {
+  async search(queryInput, modeInput, limitInput, choiceId) {
     const query = queryInput.trim();
-    const mode = contentKnowledgeSearchModeSchema.safeParse(modeInput);
+    const modelAction = knowledgeModelChoices(
+      "search",
+      sha2562(JSON.stringify({ limit: limitInput, mode: modeInput, query }))
+    );
+    const selectedMode = selectedKnowledgeMode(modelAction, choiceId);
+    const mode = contentKnowledgeSearchModeSchema.safeParse(
+      selectedMode === "lexical" ? "lexical" : modeInput
+    );
     if (query.length === 0 || query.length > 500 || !mode.success || !Number.isSafeInteger(limitInput) || limitInput < 1 || limitInput > MAXIMUM_RESULTS) {
       throw new KnowledgeCliError("DXC_KNOWLEDGE_QUERY_INVALID", "Knowledge query is invalid");
     }
@@ -2083,7 +2156,8 @@ var KnowledgeCli = class {
       if (usesSemantic && (chunks.some((chunk) => chunk.embedding === null) || quotes.some((quote) => quote.embedding === null))) {
         throw new KnowledgeCliError(
           "DXC_KNOWLEDGE_SEMANTIC_NOT_READY",
-          "All active knowledge items must have a semantic index before hybrid search"
+          "All active knowledge items must have a semantic index before hybrid search",
+          { nextAction: modelAction }
         );
       }
       const lexical = mode.data === "semantic" ? [] : lexicalRanking(database, query);
@@ -2095,9 +2169,10 @@ var KnowledgeCli = class {
         try {
           queryVector = await this.#embedder.embedQuery(query);
         } catch {
-          throw new KnowledgeCliError(
-            "DXC_KNOWLEDGE_MODEL_FAILED",
-            "Local semantic model could not process the query"
+          throw knowledgeModelUnavailable(
+            "Local semantic model could not process the query",
+            modelAction,
+            "DXC_KNOWLEDGE_MODEL_FAILED"
           );
         }
         semantic = semanticRanking(chunks, queryVector);