veryfront 0.1.83 → 0.1.85

package/esm/cli/commands/knowledge/command.d.ts

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { type ApiClient } from "../../shared/config.js";
 import type { ParsedArgs } from "../../shared/types.js";
 import { type Logger } from "../../../src/utils/index.js";
+import { type KnowledgeIngestFailedFileResult, type KnowledgeIngestFileResult, type KnowledgeIngestSkippedFileResult } from "./result.js";
 export interface KnowledgeParserResult {
     success: true;
     source_path: string;
@@ -16,17 +17,6 @@ export interface KnowledgeParserResult {
     stats: Record<string, unknown>;
     warnings: string[];
 }
-export interface KnowledgeIngestFileResult {
-    source: string;
-    localSourcePath: string;
-    outputPath: string;
-    remotePath: string;
-    slug: string;
-    sourceType: string;
-    summary: string;
-    stats: Record<string, unknown>;
-    warnings: string[];
-}
 type KnowledgeSource = {
     kind: "local";
     input: string;
@@ -37,6 +27,10 @@ type KnowledgeSource = {
     uploadPath: string;
     localPath: string;
 };
+export interface KnowledgeSourceCollection {
+    sources: KnowledgeSource[];
+    skipped: KnowledgeIngestSkippedFileResult[];
+}
 type DownloadResult = {
     uploadPath: string;
     localPath: string;
@@ -135,7 +129,7 @@ export declare function collectKnowledgeSources(options: Pick<KnowledgeIngestOpt
     client: ApiClient;
     projectSlug: string;
     downloadUploads: (uploadPaths: string[]) => Promise<DownloadResult[]>;
-}): Promise<KnowledgeSource[]>;
+}): Promise<KnowledgeSourceCollection>;
 export declare function ingestResolvedSources(sources: KnowledgeSource[], options: KnowledgeIngestOptions, deps: {
     client: ApiClient;
     projectSlug: string;
@@ -145,7 +139,10 @@ export declare function ingestResolvedSources(sources: KnowledgeSource[], option
         path: string;
     }>;
     eventLogger?: Logger | null;
-}): Promise<KnowledgeIngestFileResult[]>;
+}): Promise<{
+    ingested: KnowledgeIngestFileResult[];
+    failed: KnowledgeIngestFailedFileResult[];
+}>;
 export declare function knowledgeCommand(args: ParsedArgs): Promise<void>;
 export {};
 //# sourceMappingURL=command.d.ts.map

package/esm/cli/commands/knowledge/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/knowledge/command.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/knowledge/command.ts"],"names":[],"mappings":"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"}

package/esm/cli/commands/knowledge/command.js

@@ -10,21 +10,8 @@ import { putRemoteFileFromLocal } from "../files/command.js";
 import { knowledgeIngestPythonSource } from "./parser-source.js";
 import { createJobUserLogger, serverLogger } from "../../../src/utils/index.js";
 import { writeJobResultIfConfigured } from "../../utils/write-job-result.js";
-const SUPPORTED_EXTENSIONS = new Set([
-    ".pdf",
-    ".csv",
-    ".tsv",
-    ".docx",
-    ".xlsx",
-    ".xls",
-    ".pptx",
-    ".html",
-    ".htm",
-    ".txt",
-    ".json",
-    ".md",
-    ".mdx",
-]);
+import { classifyKnowledgeDirectoryPath, classifyKnowledgeSourcePath } from "./source-policy.js";
+import { buildKnowledgeIngestJobResult, } from "./result.js";
 const knowledgeJobLogger = serverLogger.component("knowledge-ingest");
 const KnowledgeIngestArgsSchema = z.object({
     projectSlug: z.string().optional(),
@@ -149,6 +136,15 @@ export function formatKnowledgeUploadSource(uploadPath) {
         ? normalizedPath
         : `uploads/${normalizedPath}`;
 }
+function resolveExplicitUploadPath(inputPath) {
+    const normalizedInput = normalizeKnowledgeInputPath(inputPath);
+    const displayInput = inputPath.replace(/\\/g, "/");
+    const uploadPath = normalizeProjectUploadPath(inputPath);
+    if (!uploadPath || normalizedInput.endsWith("/")) {
+        throw new Error(`Directory upload references require --path <prefix> --all: ${displayInput}`);
+    }
+    return uploadPath;
+}
 export function isLikelyLocalPath(value) {
     return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") ||
         /^[A-Za-z]:[\\/]/.test(value);
@@ -159,9 +155,6 @@ function isProjectUploadReference(value) {
     const normalizedValue = normalize(value).replace(/\\/g, "/").replace(/^\/+/, "");
     return normalizedValue === "uploads" || normalizedValue.startsWith("uploads/");
 }
-function isSupportedKnowledgeFile(path) {
-    return SUPPORTED_EXTENSIONS.has(extname(path).toLowerCase());
-}
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "document";
 }
@@ -171,32 +164,108 @@ function defaultOutputRoot() {
 export function resolveKnowledgeDownloadOutputDir(outputDir) {
     return join(outputDir, ".uploads");
 }
+function createSkippedKnowledgeSource(input) {
+    return {
+        source: input.source,
+        localSourcePath: input.localSourcePath ?? null,
+        message: input.message,
+        reason: input.reason,
+    };
+}
+function createFailedKnowledgeSource(input) {
+    return {
+        source: input.source,
+        localSourcePath: input.localSourcePath,
+        message: input.message,
+        reason: input.reason,
+    };
+}
+function classifySourceOrSkip(input) {
+    const decision = classifyKnowledgeSourcePath(input.source);
+    if (decision.kind === "ingest") {
+        return null;
+    }
+    return createSkippedKnowledgeSource({
+        source: input.source,
+        localSourcePath: input.localSourcePath,
+        message: decision.message,
+        reason: decision.reason,
+    });
+}
+function classifyDirectoryOrSkip(input) {
+    const decision = classifyKnowledgeDirectoryPath(input.source);
+    if (decision.kind === "ingest") {
+        return null;
+    }
+    return createSkippedKnowledgeSource({
+        source: input.source,
+        localSourcePath: null,
+        message: decision.message,
+        reason: decision.reason,
+    });
+}
 async function collectLocalFiles(root, recursive) {
     const fs = createFileSystem();
     const stat = await fs.stat(root);
-    if (stat.isFile)
-        return isSupportedKnowledgeFile(root) ? [root] : [];
-    if (!stat.isDirectory)
-        return [];
-    const files = [];
+    if (stat.isFile) {
+        const skipped = classifySourceOrSkip({ source: root, localSourcePath: root });
+        return skipped == null
+            ? {
+                sources: [{ kind: "local", input: root, localPath: root }],
+                skipped: [],
+            }
+            : {
+                sources: [],
+                skipped: [skipped],
+            };
+    }
+    if (!stat.isDirectory) {
+        return { sources: [], skipped: [] };
+    }
+    const skippedRootDirectory = classifyDirectoryOrSkip({ source: root });
+    if (skippedRootDirectory != null) {
+        return {
+            sources: [],
+            skipped: [skippedRootDirectory],
+        };
+    }
+    const collection = {
+        sources: [],
+        skipped: [],
+    };
     async function walk(dir) {
         for await (const entry of fs.readDir(dir)) {
             const entryPath = join(dir, entry.name);
             if (entry.isDirectory) {
+                const skipped = classifyDirectoryOrSkip({ source: entryPath });
+                if (skipped != null) {
+                    collection.skipped.push(skipped);
+                    continue;
+                }
                 if (recursive)
                     await walk(entryPath);
                 continue;
             }
-            if (entry.isFile && isSupportedKnowledgeFile(entryPath)) {
-                files.push(entryPath);
+            if (!entry.isFile) {
+                continue;
+            }
+            const skipped = classifySourceOrSkip({ source: entryPath, localSourcePath: entryPath });
+            if (skipped != null) {
+                collection.skipped.push(skipped);
+                continue;
             }
+            collection.sources.push({ kind: "local", input: root, localPath: entryPath });
         }
     }
     await walk(root);
-    return files.sort();
+    collection.sources.sort((left, right) => left.localPath.localeCompare(right.localPath));
+    collection.skipped.sort((left, right) => left.source.localeCompare(right.source));
+    return collection;
 }
 function buildSourceReference(source) {
-    return source.kind === "upload" ? formatKnowledgeUploadSource(source.uploadPath) : source.input;
+    return source.kind === "upload"
+        ? formatKnowledgeUploadSource(source.uploadPath)
+        : source.localPath;
 }
 function buildSuggestedSlug(source, index) {
     const normalized = normalize(source.kind === "upload" ? source.uploadPath : source.localPath).replace(/\\/g, "/");
@@ -259,35 +328,44 @@ export async function runKnowledgeParser(input) {
     const outputJsonPath = `${tempDir}/output.json`;
     const scriptPath = `${tempDir}/ingest_document_to_knowledge.py`;
     try {
-        await dntShim.Deno.writeTextFile(inputJsonPath, JSON.stringify({
-            file_path: input.filePath,
-            output_dir: input.outputDir,
-            description: input.description,
-            slug: input.slug,
-            source_reference: input.sourceReference,
-        }));
-        await dntShim.Deno.writeTextFile(scriptPath, knowledgeIngestPythonSource);
-        let result;
         try {
-            result = await new dntShim.Deno.Command("python3", {
-                args: [scriptPath, "--input-json", inputJsonPath, "--output-json", outputJsonPath],
-                ...(input.env ? { env: input.env } : {}),
-                stdout: "piped",
-                stderr: "piped",
-            }).output();
+            await dntShim.Deno.writeTextFile(inputJsonPath, JSON.stringify({
+                file_path: input.filePath,
+                output_dir: input.outputDir,
+                description: input.description,
+                slug: input.slug,
+                source_reference: input.sourceReference,
+            }));
+            await dntShim.Deno.writeTextFile(scriptPath, knowledgeIngestPythonSource);
+            let result;
+            try {
+                result = await new dntShim.Deno.Command("python3", {
+                    args: [scriptPath, "--input-json", inputJsonPath, "--output-json", outputJsonPath],
+                    ...(input.env ? { env: input.env } : {}),
+                    stdout: "piped",
+                    stderr: "piped",
+                }).output();
+            }
+            catch (error) {
+                if (error instanceof dntShim.Deno.errors.NotFound) {
+                    throw new Error("python3 is required. Install python3 and the supported parser packages, or run the command inside the Veryfront sandbox.");
+                }
+                throw error;
+            }
+            if (result.code !== 0) {
+                const stderr = new TextDecoder().decode(result.stderr).trim();
+                throw new Error(stderr || "parser exited unsuccessfully");
+            }
+            const raw = await dntShim.Deno.readTextFile(outputJsonPath);
+            return JSON.parse(raw);
         }
         catch (error) {
-            if (error instanceof dntShim.Deno.errors.NotFound) {
-                throw new Error("knowledge ingest requires python3. Install python3 and the supported parser packages, or run the command inside the Veryfront sandbox.");
+            if (error instanceof Error && error.message.startsWith("knowledge ingest parser failed")) {
+                throw error;
             }
-            throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`knowledge ingest parser failed: ${message}`);
         }
-        if (result.code !== 0) {
-            const stderr = new TextDecoder().decode(result.stderr).trim();
-            throw new Error(`knowledge ingest parser failed${stderr ? `: ${stderr}` : ""}`);
-        }
-        const raw = await dntShim.Deno.readTextFile(outputJsonPath);
-        return JSON.parse(raw);
     }
     finally {
         await dntShim.Deno.remove(tempDir, { recursive: true }).catch(() => undefined);
@@ -298,21 +376,27 @@ export async function collectKnowledgeSources(options, deps) {
     if (options.sources.length > 0) {
         const explicitSources = [];
         const uploadTargets = [];
+        const skipped = [];
         for (const input of options.sources) {
             if (!isProjectUploadReference(input) && await fs.exists(input)) {
-                const localFiles = await collectLocalFiles(input, options.recursive);
-                if (!localFiles.length)
-                    throw new Error(`No supported files found at ${input}`);
+                const collection = await collectLocalFiles(input, options.recursive);
                 explicitSources.push({
                     kind: "local",
-                    sources: localFiles.map((localPath) => ({ kind: "local", input, localPath })),
+                    collection,
                 });
                 continue;
             }
             if (isLikelyLocalPath(input)) {
                 throw new Error(`Local file not found: ${input}`);
             }
-            const uploadPath = normalizeProjectUploadPath(input);
+            const uploadPath = resolveExplicitUploadPath(input);
+            const skippedUpload = classifySourceOrSkip({
+                source: formatKnowledgeUploadSource(uploadPath),
+            });
+            if (skippedUpload != null) {
+                skipped.push(skippedUpload);
+                continue;
+            }
             explicitSources.push({ kind: "upload", input, uploadPath });
             uploadTargets.push(uploadPath);
         }
@@ -326,7 +410,14 @@ export async function collectKnowledgeSources(options, deps) {
         const resolvedSources = [];
         for (const source of explicitSources) {
             if (source.kind === "local") {
-                resolvedSources.push(...source.sources);
+                for (const localSource of source.collection.sources) {
+                    resolvedSources.push({
+                        kind: "local",
+                        input: localSource.input,
+                        localPath: localSource.localPath,
+                    });
+                }
+                skipped.push(...source.collection.skipped);
                 continue;
             }
             const matchingDownloads = downloadsByPath.get(source.uploadPath);
@@ -341,16 +432,16 @@ export async function collectKnowledgeSources(options, deps) {
                 localPath: download.localPath,
             });
         }
-        return resolvedSources;
+        return {
+            sources: resolvedSources,
+            skipped,
+        };
     }
     if (!options.path || !options.all) {
         throw new Error("Provide one or more source paths or use --path with --all.");
     }
     if (!isProjectUploadReference(options.path) && await fs.exists(options.path)) {
-        const localFiles = await collectLocalFiles(options.path, options.recursive);
-        if (!localFiles.length)
-            throw new Error(`No supported files found under ${options.path}`);
-        return localFiles.map((localPath) => ({ kind: "local", input: options.path, localPath }));
+        return collectLocalFiles(options.path, options.recursive);
     }
     const displayUploadPrefix = normalizeKnowledgeInputPath(options.path);
     const uploadPrefix = normalizeProjectUploadPath(options.path);
@@ -360,74 +451,131 @@ export async function collectKnowledgeSources(options, deps) {
         limit: 100,
     });
     let uploads = await listUploadsForPrefix(uploadPrefix || undefined);
+    let skipped = uploads.flatMap((item) => {
+        if (item.type === "folder") {
+            return [];
+        }
+        const skippedUpload = classifySourceOrSkip({
+            source: formatKnowledgeUploadSource(item.path),
+        });
+        return skippedUpload == null ? [] : [skippedUpload];
+    });
     let uploadTargets = uploads
-        .filter((item) => item.type !== "folder" && isSupportedKnowledgeFile(item.path))
-        .map((item) => item.path);
+        .filter((item) => item.type !== "folder")
+        .map((item) => item.path)
+        .filter((uploadPath) => classifySourceOrSkip({ source: formatKnowledgeUploadSource(uploadPath) }) == null);
     if (!uploadTargets.length && uploadPrefix && !uploadPrefix.endsWith("/")) {
         uploads = await listUploadsForPrefix(`${uploadPrefix}/`);
+        skipped = uploads.flatMap((item) => {
+            if (item.type === "folder") {
+                return [];
+            }
+            const skippedUpload = classifySourceOrSkip({
+                source: formatKnowledgeUploadSource(item.path),
+            });
+            return skippedUpload == null ? [] : [skippedUpload];
+        });
         uploadTargets = uploads
-            .filter((item) => item.type !== "folder" && isSupportedKnowledgeFile(item.path))
-            .map((item) => item.path);
+            .filter((item) => item.type !== "folder")
+            .map((item) => item.path)
+            .filter((uploadPath) => classifySourceOrSkip({ source: formatKnowledgeUploadSource(uploadPath) }) == null);
     }
-    if (!uploadTargets.length) {
+    if (!uploadTargets.length && skipped.length === 0) {
         throw new Error(`No supported uploads found under ${displayUploadPrefix}`);
     }
     const downloads = await deps.downloadUploads(uploadTargets);
-    return downloads.map((download) => ({
-        kind: "upload",
-        input: options.path,
-        uploadPath: download.uploadPath,
-        localPath: download.localPath,
-    }));
+    return {
+        sources: downloads.map((download) => ({
+            kind: "upload",
+            input: options.path,
+            uploadPath: download.uploadPath,
+            localPath: download.localPath,
+        })),
+        skipped,
+    };
 }
 export async function ingestResolvedSources(sources, options, deps) {
     if (options.slug && sources.length !== 1) {
         throw new Error("--slug can only be used with a single explicit source.");
     }
     const slugs = options.slug ? [options.slug] : ensureUniqueSlugs(sources);
-    const results = [];
-    for (const [index, source] of sources.entries()) {
-        deps.eventLogger?.info("Processing knowledge source", {
-            phase: "file_processing",
+    const ingested = [];
+    const failed = [];
+    const recordSourceFailure = (source, sourceReference, index, message, reason) => {
+        deps.eventLogger?.error("Knowledge source failed", {
+            phase: "file_failed",
             progress_current: index + 1,
             progress_total: sources.length,
             source_name: buildKnowledgeSourceName(source),
+            error: message,
         });
-        const parser = await deps.runParser({
-            filePath: source.localPath,
-            outputDir: deps.outputDir,
-            description: options.description,
-            slug: slugs[index],
-            sourceReference: buildSourceReference(source),
-        });
-        const remotePath = deriveKnowledgeRemotePath(parser.sandbox_output_path, deps.outputDir, options.knowledgePath);
-        const uploaded = await deps.uploadKnowledgeFile(remotePath, parser.sandbox_output_path);
-        deps.eventLogger?.info("Knowledge source ingested", {
-            phase: "file_completed",
+        failed.push(createFailedKnowledgeSource({
+            source: sourceReference,
+            localSourcePath: source.localPath,
+            message,
+            reason,
+        }));
+    };
+    for (const [index, source] of sources.entries()) {
+        const sourceReference = buildSourceReference(source);
+        deps.eventLogger?.info("Processing knowledge source", {
+            phase: "file_processing",
             progress_current: index + 1,
             progress_total: sources.length,
             source_name: buildKnowledgeSourceName(source),
-            remote_path: uploaded.path,
-            warning_count: parser.warnings.length,
         });
-        if (parser.warnings.length > 0) {
-            deps.eventLogger?.warn("Knowledge source emitted warnings", {
-                phase: "file_warning",
+        let parser;
+        try {
+            parser = await deps.runParser({
+                filePath: source.localPath,
+                outputDir: deps.outputDir,
+                description: options.description,
+                slug: slugs[index],
+                sourceReference,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            recordSourceFailure(source, sourceReference, index, message, "parser_error");
+            continue;
+        }
+        try {
+            const remotePath = deriveKnowledgeRemotePath(parser.sandbox_output_path, deps.outputDir, options.knowledgePath);
+            const uploaded = await deps.uploadKnowledgeFile(remotePath, parser.sandbox_output_path);
+            deps.eventLogger?.info("Knowledge source ingested", {
+                phase: "file_completed",
                 progress_current: index + 1,
                 progress_total: sources.length,
                 source_name: buildKnowledgeSourceName(source),
+                remote_path: uploaded.path,
                 warning_count: parser.warnings.length,
             });
+            if (parser.warnings.length > 0) {
+                deps.eventLogger?.warn("Knowledge source emitted warnings", {
+                    phase: "file_warning",
+                    progress_current: index + 1,
+                    progress_total: sources.length,
+                    source_name: buildKnowledgeSourceName(source),
+                    warning_count: parser.warnings.length,
+                });
+            }
+            ingested.push(createKnowledgeIngestResult({
+                source: sourceReference,
+                localSourcePath: source.localPath,
+                outputPath: parser.sandbox_output_path,
+                remotePath: uploaded.path,
+                parser,
+            }));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            recordSourceFailure(source, sourceReference, index, message, "upload_error");
         }
-        results.push(createKnowledgeIngestResult({
-            source: buildSourceReference(source),
-            localSourcePath: source.localPath,
-            outputPath: parser.sandbox_output_path,
-            remotePath: uploaded.path,
-            parser,
-        }));
     }
-    return results;
+    return {
+        ingested,
+        failed,
+    };
 }
 export async function knowledgeCommand(args) {
     const subcommand = typeof args._[1] === "string" ? args._[1] : undefined;
@@ -452,20 +600,33 @@ export async function knowledgeCommand(args) {
                 const downloadOutputDir = resolveKnowledgeDownloadOutputDir(outputDir);
                 const eventLogger = createKnowledgeIngestEventLogger();
                 try {
+                    const sourceMode = options.path ? "path_prefix" : "explicit_sources";
                     eventLogger?.info("Starting knowledge ingest", {
                         phase: "started",
-                        mode: options.path ? "path_prefix" : "explicit_sources",
+                        mode: sourceMode,
                     });
-                    const sources = await collectKnowledgeSources(options, {
+                    const collection = await collectKnowledgeSources(options, {
                         client,
                         projectSlug: config.projectSlug,
                         downloadUploads: (uploadPaths) => Promise.all(uploadPaths.map((uploadPath) => downloadUploadToFile(client, config.projectSlug, uploadPath, downloadOutputDir))),
                     });
+                    const requestedCount = collection.sources.length + collection.skipped.length;
+                    if (requestedCount === 0) {
+                        throw new Error("No supported knowledge sources were found.");
+                    }
                     eventLogger?.info("Resolved knowledge sources", {
                         phase: "sources_resolved",
-                        progress_total: sources.length,
+                        progress_total: requestedCount,
+                        ingestable_count: collection.sources.length,
+                        skipped_count: collection.skipped.length,
                     });
-                    const results = await ingestResolvedSources(sources, options, {
+                    if (collection.skipped.length > 0) {
+                        eventLogger?.warn("Skipped knowledge sources", {
+                            phase: "sources_skipped",
+                            skipped_count: collection.skipped.length,
+                        });
+                    }
+                    const results = await ingestResolvedSources(collection.sources, options, {
                         client,
                         projectSlug: config.projectSlug,
                         outputDir,
@@ -473,22 +634,45 @@ export async function knowledgeCommand(args) {
                         eventLogger,
                         uploadKnowledgeFile: (remotePath, localPath) => putRemoteFileFromLocal(client, config.projectSlug, remotePath, localPath),
                     });
+                    const jobResult = buildKnowledgeIngestJobResult({
+                        requestedCount,
+                        sourceMode,
+                        knowledgePath: options.knowledgePath,
+                        ingested: results.ingested,
+                        skipped: collection.skipped,
+                        failed: results.failed,
+                    });
                     eventLogger?.info("Completed knowledge ingest", {
                         phase: "completed",
-                        progress_current: results.length,
-                        progress_total: results.length,
+                        progress_current: requestedCount,
+                        progress_total: requestedCount,
+                        ingested_count: jobResult.summary.ingested_count,
+                        skipped_count: jobResult.summary.skipped_count,
+                        failed_count: jobResult.summary.failed_count,
                     });
-                    await writeJobResultIfConfigured(results);
+                    await writeJobResultIfConfigured(jobResult);
                     if (options.json) {
-                        printJson(results);
+                        printJson(jobResult);
                         return;
                     }
-                    for (const result of results) {
+                    for (const result of jobResult.ingested) {
                         if (!options.quiet) {
                             cliLogger.info(`Ingested ${result.source} -> ${result.remotePath}`);
                             cliLogger.info(`  ${result.summary}`);
                         }
                     }
+                    for (const skipped of jobResult.skipped) {
+                        if (!options.quiet) {
+                            cliLogger.warn(`Skipped ${skipped.source}`);
+                            cliLogger.warn(`  ${skipped.message}`);
+                        }
+                    }
+                    for (const failure of jobResult.failed) {
+                        if (!options.quiet) {
+                            cliLogger.error(`Failed ${failure.source}`);
+                            cliLogger.error(`  ${failure.message}`);
+                        }
+                    }
                 }
                 catch (error) {
                     eventLogger?.error("Knowledge ingest failed", {

package/esm/cli/commands/knowledge/parser-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser-source.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/knowledge/parser-source.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,QAugBvC,CAAC"}
+{"version":3,"file":"parser-source.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/knowledge/parser-source.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B,QA2jBvC,CAAC"}