@tryformation/querylight-cli 0.2.5 → 0.2.6

package/dist/core/archive.d.ts

@@ -0,0 +1,18 @@
+type WorkspaceArchiveResolution = {
+    workspacePath: string;
+    archivePath?: string;
+};
+export declare function isWorkspaceArchivePath(workspacePath: string): boolean;
+export declare function packageWorkspaceArchive({ workspacePath, outputPath, force }: {
+    workspacePath: string;
+    outputPath: string;
+    force?: boolean;
+}): Promise<{
+    workspacePath: string;
+    archivePath: string;
+    fileCount: number;
+    sizeBytes: number;
+}>;
+export declare function resolveReadableWorkspace(workspacePath: string): Promise<WorkspaceArchiveResolution>;
+export declare function assertWritableWorkspacePath(workspacePath: string): Promise<string>;
+export {};

package/dist/index.js

@@ -2236,7 +2236,6 @@ async function createSparseQueryEncoder(cacheDir, modelId, queryTokenWeights) {
   return async (text) => {
     const features = await tokenizer([text], {
       truncation: true,
-      return_attention_mask: false,
       return_token_type_ids: false
     });
     return buildSparseQueryVector(normalizeTokenIds(features.input_ids), queryTokenWeights);
@@ -3260,18 +3259,68 @@ async function searchIndex({
 
 // src/server/search-api.ts
 import { createServer } from "http";
-import { readdir, stat as stat4 } from "fs/promises";
+import { readdir as readdir2, stat as stat5 } from "fs/promises";
+import path20 from "path";
+
+// src/core/archive.ts
+import { mkdir as mkdir10, readdir, readFile as readFile11, rm as rm5, stat as stat4, writeFile as writeFile9 } from "fs/promises";
+import os2 from "os";
 import path19 from "path";
+import { unzipSync, zipSync } from "fflate";
+function isWorkspaceArchivePath(workspacePath) {
+  return workspacePath.toLowerCase().endsWith(".zip");
+}
+function assertSafeArchiveEntry(name) {
+  const normalized = path19.posix.normalize(name);
+  if (name.startsWith("/") || normalized === "." || normalized.startsWith("../") || normalized.includes("/../")) {
+    throw new CliError(`unsafe archive entry: ${name}`, "WORKSPACE_ERROR", 3 /* WorkspaceError */);
+  }
+}
+async function archiveCachePath(archivePath) {
+  const info = await stat4(archivePath);
+  const key = sha256(`${path19.resolve(archivePath)}:${info.size}:${info.mtimeMs}`).slice(0, 24);
+  return path19.join(os2.tmpdir(), "qli-workspace-archives", key);
+}
+async function resolveReadableWorkspace(workspacePath) {
+  const resolved = path19.resolve(workspacePath);
+  if (!isWorkspaceArchivePath(resolved)) {
+    return { workspacePath: await assertWorkspaceExists(resolved) };
+  }
+  const archive = await readFile11(resolved);
+  const extractRoot = await archiveCachePath(resolved);
+  const workspaceRoot = path19.join(extractRoot, "workspace");
+  try {
+    await assertWorkspaceExists(workspaceRoot);
+    return { workspacePath: workspaceRoot, archivePath: resolved };
+  } catch {
+  }
+  await rm5(extractRoot, { recursive: true, force: true });
+  await mkdir10(workspaceRoot, { recursive: true });
+  const entries = unzipSync(new Uint8Array(archive));
+  await Promise.all(Object.entries(entries).map(async ([entryName, data]) => {
+    assertSafeArchiveEntry(entryName);
+    const target = path19.join(workspaceRoot, ...entryName.split("/"));
+    if (entryName.endsWith("/")) {
+      await mkdir10(target, { recursive: true });
+      return;
+    }
+    await mkdir10(path19.dirname(target), { recursive: true });
+    await writeFile9(target, Buffer.from(data));
+  }));
+  return { workspacePath: await assertWorkspaceExists(workspaceRoot), archivePath: resolved };
+}
+
+// src/server/search-api.ts
 async function pathIsDirectory(candidatePath) {
   try {
-    return (await stat4(candidatePath)).isDirectory();
+    return (await stat5(candidatePath)).isDirectory();
   } catch {
     return false;
   }
 }
 async function discoverKnowledgeBases(workspacePath) {
   try {
-    const singleWorkspace = await assertWorkspaceExists(workspacePath);
+    const singleWorkspace = (await resolveReadableWorkspace(workspacePath)).workspacePath;
     const config = await loadConfig(singleWorkspace);
     const index = await loadHydratedIndex(singleWorkspace);
     return {
@@ -3288,19 +3337,20 @@ async function discoverKnowledgeBases(workspacePath) {
       throw error;
     }
   }
-  const resolvedRoot = path19.resolve(workspacePath);
+  const resolvedRoot = path20.resolve(workspacePath);
   if (!await pathIsDirectory(resolvedRoot)) {
     throw new CliError(`workspace path does not exist: ${resolvedRoot}`, "WORKSPACE_ERROR", 3 /* WorkspaceError */);
   }
-  const entries = await readdir(resolvedRoot, { withFileTypes: true });
-  const knowledgeBases = (await Promise.all(entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
-    const candidateWorkspace = path19.join(resolvedRoot, entry.name, ".kb");
+  const entries = await readdir2(resolvedRoot, { withFileTypes: true });
+  const knowledgeBases = (await Promise.all(entries.filter((entry) => entry.isDirectory() || entry.isFile() && isWorkspaceArchivePath(entry.name)).map(async (entry) => {
+    const candidateWorkspace = entry.isDirectory() ? path20.join(resolvedRoot, entry.name, ".kb") : path20.join(resolvedRoot, entry.name);
+    const knowledgeBaseName = entry.isDirectory() ? entry.name : entry.name.replace(/\.zip$/i, "");
     try {
-      const workspace = await assertWorkspaceExists(candidateWorkspace);
+      const workspace = entry.isDirectory() ? await assertWorkspaceExists(candidateWorkspace) : (await resolveReadableWorkspace(candidateWorkspace)).workspacePath;
       const config = await loadConfig(workspace);
       const index = await loadHydratedIndex(workspace);
       return {
-        name: entry.name,
+        name: knowledgeBaseName,
         workspacePath: workspace,
         configuredIndexName: config.index.name,
         index
@@ -3314,7 +3364,7 @@ async function discoverKnowledgeBases(workspacePath) {
   }))).filter((knowledgeBase) => knowledgeBase != null);
   if (knowledgeBases.length === 0) {
     throw new CliError(
-      `no knowledge bases found at ${resolvedRoot}; use a .kb workspace or a directory of named subdirectories that each contain .kb`,
+      `no knowledge bases found at ${resolvedRoot}; use a .kb workspace, a .zip workspace, or a directory of .zip files or named subdirectories that each contain .kb`,
       "WORKSPACE_ERROR",
       3 /* WorkspaceError */
     );
@@ -3448,7 +3498,7 @@ async function startSearchApiServer({
 }
 
 // src/query/related-service.ts
-import path20 from "path";
+import path21 from "path";
 function cosineSimilarity2(left, right) {
   let dot = 0;
   let leftNorm = 0;
@@ -3524,7 +3574,7 @@ async function findRelatedDocuments({
   if (!await fileExists(denseVectorPath(workspacePath))) {
     throw new CliError("dense vector index is not built; run `qli models pull --dense` and `qli rebuild`", "DENSE_INDEX_MISSING", 7 /* QueryError */);
   }
-  const documents = await readJsonl(path20.join(workspacePath, "documents", "documents.jsonl"));
+  const documents = await readJsonl(path21.join(workspacePath, "documents", "documents.jsonl"));
   const selected = resolveDocumentSelector(documents, document);
   const densePayload = await readDensePayload(workspacePath);
   const vectors = buildDocumentVectors(documents, densePayload.chunks, densePayload.metadata.dimensions);
@@ -3597,7 +3647,7 @@ async function createContext({
 }
 
 // src/report/diff-service.ts
-import path21 from "path";
+import path22 from "path";
 function chooseBaselineRun(runs, since) {
   if (since === "last-run") {
     return runs.at(-1);
@@ -3613,7 +3663,7 @@ async function diffWorkspace({
   documentId,
   since
 }) {
-  const current = await readJsonl(path21.join(workspacePath, "documents", "documents.jsonl"));
+  const current = await readJsonl(path22.join(workspacePath, "documents", "documents.jsonl"));
   const baseline = chooseBaselineRun(await listRuns(workspacePath), since);
   const previous = new Map((baseline?.documentsSnapshot ?? []).map((document) => [document.id, document]));
   const changedDocuments = current.filter((document) => (!sourceId || document.sourceId === sourceId) && (!documentId || document.id === documentId)).filter((document) => {

package/dist/vector/runtime.d.ts

@@ -19,10 +19,7 @@ export declare function runSparsePython({ workspacePath, config, payload, import
     importMetaUrl: string;
 }): Promise<string>;
 export declare function getDenseTransformersRuntime(cacheDir: string): Promise<{
-    env: {
-        cacheDir: string;
-        allowLocalModels: boolean;
-    };
+    env: typeof import("@huggingface/transformers").env;
     pipeline: typeof import("@huggingface/transformers").pipeline;
 }>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryformation/querylight-cli",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Querylight CLI for building and querying local knowledge bases.",
   "license": "MIT",
   "homepage": "https://github.com/formation-res/querylight-cli#readme",
@@ -40,14 +40,15 @@
     "verify:release-version": "node scripts/assert-release-version.mjs"
   },
   "dependencies": {
-    "@huggingface/transformers": "^3.8.1",
+    "@huggingface/transformers": "^4.2.0",
     "@tryformation/querylight-ts": "^0.11.0",
     "cheerio": "^1.2.0",
     "cli-table3": "^0.6.5",
-    "commander": "^14.0.3",
+    "commander": "^15.0.0",
     "fast-glob": "^3.3.3",
-    "feedparser": "^2.2.10",
+    "feedparser": "^2.6.0",
     "feedsmith": "^2.9.4",
+    "fflate": "^0.8.3",
     "gray-matter": "^4.0.3",
     "mammoth": "^1.12.0",
     "pdf-parse": "^2.4.5",
@@ -56,12 +57,14 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@types/feedparser": "^2.2.8",
-    "@types/node": "^25.8.0",
+    "@types/node": "^26.0.1",
     "@types/pdf-parse": "^1.1.5",
     "@types/turndown": "^5.0.6",
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.6"
+    "vitest": "^4.1.9"
+  },
+  "overrides": {
+    "esbuild": "^0.28.1"
   }
 }