@tryformation/querylight-cli 0.2.4 → 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/core/constants.d.ts

@@ -1,5 +1,5 @@
-export declare const PACKAGE_NAME = "@tryformation/querylight-cli";
-export declare const PACKAGE_VERSION = "0.2.3";
+export declare const PACKAGE_NAME: string;
+export declare const PACKAGE_VERSION: string;
 export declare const DEFAULT_WORKSPACE = ".kb";
 export declare const DEFAULT_SHARED_MODEL_CACHE_DIR = "~/.qli/models/huggingface";
 export declare const LEGACY_WORKSPACE_MODEL_CACHE_DIR = ".kb/models/huggingface";

package/dist/index.js

@@ -22,6 +22,11 @@ import path from "path";
 import YAML from "yaml";
 
 // src/core/constants.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var packageJson = require2("../../package.json");
+var PACKAGE_NAME = packageJson.name;
+var PACKAGE_VERSION = packageJson.version;
 var DEFAULT_SHARED_MODEL_CACHE_DIR = "~/.qli/models/huggingface";
 var LEGACY_WORKSPACE_MODEL_CACHE_DIR = ".kb/models/huggingface";
 
@@ -53,6 +58,9 @@ var defaultConfig = () => ({
     maxContextChars: 12e3,
     citationStyle: "markdown"
   },
+  search: {
+    defaultTopK: 50
+  },
   retrieval: {
     defaultMode: "lexical",
     dense: {
@@ -74,12 +82,12 @@ var defaultConfig = () => ({
     }
   },
   crawler: {
-    defaultUserAgent: "querylight-cli/0.1",
+    defaultUserAgent: "querylight-cli",
     obeyRobotsTxt: true,
     rateLimitMs: 1e3,
     maxConcurrentRequests: 5,
     renderJs: false,
-    retentionDays: 365,
+    retentionDays: 30,
     fetchArticles: true
   },
   limits: {
@@ -123,6 +131,10 @@ async function loadConfig(workspacePath, configPath) {
       ...defaults.rag,
       ...parsed.rag ?? {}
     },
+    search: {
+      ...defaults.search,
+      ...parsed.search ?? {}
+    },
     retrieval: {
       ...defaults.retrieval,
       ...parsed.retrieval ?? {},
@@ -1069,7 +1081,7 @@ async function fetchUrlDocument({
   publicationDate
 }) {
   const headers = {
-    "user-agent": source.crawl?.userAgent ?? "querylight-cli/0.1"
+    "user-agent": source.crawl?.userAgent ?? "querylight-cli"
   };
   if (previous?.httpCache?.etag) {
     headers["if-none-match"] = previous.httpCache.etag;
@@ -1368,7 +1380,7 @@ async function purgeDocuments(workspacePath, documentIds, documents) {
 async function fetchFeedText(source) {
   const response = await fetch(source.uri, {
     headers: {
-      "user-agent": source.crawl?.userAgent ?? "querylight-cli/0.1"
+      "user-agent": source.crawl?.userAgent ?? "querylight-cli"
     }
   });
   if (!response.ok) {
@@ -2224,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);
@@ -3248,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 {
@@ -3276,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
@@ -3302,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 */
     );
@@ -3436,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;
@@ -3512,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);
@@ -3585,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);
@@ -3601,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/types/models.d.ts

@@ -173,6 +173,9 @@ export type WorkspaceConfig = {
         maxContextChars: number;
         citationStyle: "markdown";
     };
+    search: {
+        defaultTopK: number;
+    };
     retrieval: {
         defaultMode: RetrievalMode;
         dense: DenseVectorModelConfig;

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.4",
+  "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",
@@ -36,17 +36,19 @@
     "test:watch": "vitest",
     "lint": "tsc --noEmit",
     "check": "npm run lint && npm test",
-    "prepublishOnly": "npm run check && npm run build"
+    "prepublishOnly": "npm run check && npm run build && npm run verify:release-version",
+    "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",
@@ -55,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"
   }
 }

package/scripts/assert-release-version.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import packageJson from "../package.json" with { type: "json" };
+
+function run(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...options
+    });
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr });
+        return;
+      }
+      reject(new Error(`${command} ${args.join(" ")} failed with exit code ${code}\n${stderr}`));
+    });
+  });
+}
+
+const workspaceRoot = await mkdtemp(path.join(os.tmpdir(), "qli-release-version-"));
+const workspacePath = path.join(workspaceRoot, ".kb");
+
+try {
+  const { stdout } = await run("node", ["dist/cli/main.js", "init", "--workspace", workspacePath, "--json"], {
+    cwd: new URL("..", import.meta.url)
+  });
+  const parsed = JSON.parse(stdout);
+
+  assert.equal(parsed.ok, true, "Expected qli init --json to succeed");
+  assert.equal(parsed.version, packageJson.version, `Built CLI reported version ${parsed.version}, expected ${packageJson.version}`);
+  process.stdout.write(`Verified built CLI version ${parsed.version}\n`);
+} finally {
+  await rm(workspaceRoot, { recursive: true, force: true });
+}