@wanshi-kg/wanshi 0.1.0

package/dist/core/di/ContainerFactory.js

@@ -0,0 +1,670 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerFactory = exports.TYPES = void 0;
+const DIContainer_1 = require("./DIContainer");
+const processor_1 = require("../processor");
+const LlmContentClassifier_1 = require("../processor/classifier/LlmContentClassifier");
+const ObjectDetectionService_1 = require("../cv/ObjectDetectionService");
+const vocabulary_1 = require("../knowledge/vocabulary");
+const crypto_1 = require("crypto");
+const trace_1 = require("../trace");
+const cost_1 = require("../cost");
+/**
+ * Service identifiers for dependency injection
+ */
+exports.TYPES = {
+    Logger: Symbol.for("Logger"),
+    LLMService: Symbol.for("LLMService"),
+    EmbeddingService: Symbol.for("EmbeddingService"),
+    PromptManager: Symbol.for("PromptManager"),
+    FileDiscoveryService: Symbol.for("FileDiscoveryService"),
+    FileReaderFactory: Symbol.for("FileReaderFactory"),
+    FileProcessor: Symbol.for("FileProcessor"),
+    ContentClassifier: Symbol.for("ContentClassifier"),
+    TextChunker: Symbol.for("TextChunker"),
+    KnowledgeGraphBuilder: Symbol.for("KnowledgeGraphBuilder"),
+    KnowledgeGraphSearch: Symbol.for("KnowledgeGraphSearch"),
+    KnowledgeGraphMerger: Symbol.for("KnowledgeGraphMerger"),
+    DirectoryProcessor: Symbol.for("DirectoryProcessor"),
+    KnowledgeGraphExportService: Symbol.for("KnowledgeGraphExportService"),
+    ProcessingOptions: Symbol.for("ProcessingOptions"),
+    CheckpointService: Symbol.for("CheckpointService"),
+    ProgressEmitter: Symbol.for("ProgressEmitter"),
+    CorpusAnalyzer: Symbol.for("CorpusAnalyzer"),
+    AstSeedService: Symbol.for("AstSeedService"),
+    FetchCacheService: Symbol.for("FetchCacheService"),
+    GatedFetcher: Symbol.for("GatedFetcher"),
+    // Phase 2 — citation span-fetch
+    CitationResolver: Symbol.for("CitationResolver"),
+    GrobidClient: Symbol.for("GrobidClient"),
+    CitationFetcher: Symbol.for("CitationFetcher"),
+    CitationFetchCache: Symbol.for("CitationFetchCache"),
+    StructuredAdapterRegistry: Symbol.for("StructuredAdapterRegistry"),
+};
+/**
+ * Factory for creating configured DI containers
+ */
+class ContainerFactory {
+    /**
+     * Create a fully configured container
+     */
+    static createContainer(config) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const container = new DIContainer_1.DIContainer();
+        const processingOptions = config.processingOptions;
+        // Apply run-global domain-gate thresholds (A1) before any lazy factory — the
+        // enum path, prompt hints, cascade, and harness then all gate on the same
+        // configured values (KG-05 single source).
+        (0, vocabulary_1.configureDomainGate)({
+            lowConfidence: (_a = processingOptions.classifier) === null || _a === void 0 ? void 0 : _a.lowConfidenceThreshold,
+            mixedDomain: (_b = processingOptions.classifier) === null || _b === void 0 ? void 0 : _b.mixedDomainThreshold,
+        });
+        // Configure the run-global debug trace singleton (observe-only; off by default).
+        // Mint a runId from time + a config digest so each run's trace is identifiable.
+        const traceCfg = (_c = processingOptions.trace) !== null && _c !== void 0 ? _c : { enabled: false };
+        const runId = new Date().toISOString() +
+            "-" +
+            (0, crypto_1.createHash)("sha1")
+                .update(`${processingOptions.output}␟${(_d = processingOptions.llm) === null || _d === void 0 ? void 0 : _d.model}␟${(_e = processingOptions.llm) === null || _e === void 0 ? void 0 : _e.promptVersion}`)
+                .digest("hex")
+                .slice(0, 8);
+        trace_1.trace.configure({
+            enabled: !!traceCfg.enabled,
+            path: traceCfg.path || (processingOptions.output ? `${processingOptions.output}.trace.jsonl` : undefined),
+            runId,
+        });
+        // Configure the run-global cost meter singleton (off by default; logger attached
+        // later in DirectoryProcessor where it's resolved). Setting maxCost auto-enables.
+        const costCfg = (_f = processingOptions.cost) !== null && _f !== void 0 ? _f : { enabled: false, currency: "USD", prices: {} };
+        cost_1.meter.configure({
+            enabled: !!costCfg.enabled || costCfg.maxCost != null,
+            maxCost: costCfg.maxCost,
+            currency: costCfg.currency || "USD",
+            prices: (_g = costCfg.prices) !== null && _g !== void 0 ? _g : {},
+            ledgerPath: costCfg.ledgerPath || (processingOptions.output ? `${processingOptions.output}.cost.json` : undefined),
+        });
+        // Register configuration
+        container.registerValue(exports.TYPES.ProcessingOptions, processingOptions);
+        // Register logger
+        container.register(exports.TYPES.Logger, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { LoggerFactory } = yield Promise.resolve().then(() => __importStar(require("../../shared/logger")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            return LoggerFactory.createLogger(options);
+        }));
+        // Register progress emitter. NDJSON-on-stdout when --progress-ndjson is set
+        // (for a parent process / UI), otherwise a no-op so the normal path is
+        // unaffected.
+        container.register(exports.TYPES.ProgressEmitter, (c) => __awaiter(this, void 0, void 0, function* () {
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const { NoopProgressEmitter, NdjsonProgressEmitter } = yield Promise.resolve().then(() => __importStar(require("../progress")));
+            return options.logging.progressNdjson
+                ? new NdjsonProgressEmitter(process.stdout)
+                : new NoopProgressEmitter();
+        }));
+        // Register LLM services (provider-selectable: local Ollama or OpenAI-compatible)
+        container.register(exports.TYPES.LLMService, (c) => __awaiter(this, void 0, void 0, function* () {
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const llmOptions = {
+                model: options.llm.model,
+                host: options.llm.host,
+                apiKey: options.llm.apiKey,
+                images: options.readers.images !== "disabled",
+                temperature: options.llm.temperature,
+                contextLength: options.llm.contextLength,
+                repeatPenalty: options.llm.repeatPenalty,
+                seed: options.llm.seed,
+                maxTokens: options.llm.maxTokens,
+            };
+            if (options.llm.provider === "openai") {
+                const { OpenAICompatibleService } = yield Promise.resolve().then(() => __importStar(require("../llm/OpenAICompatibleService")));
+                logger.info(`Using OpenAI-compatible provider at ${options.llm.host}`);
+                return new OpenAICompatibleService(llmOptions, logger);
+            }
+            const { OllamaService } = yield Promise.resolve().then(() => __importStar(require("../llm/OllamaService")));
+            return new OllamaService(llmOptions, logger);
+        }));
+        // Register Embedding service (independent provider from generation)
+        container.register(exports.TYPES.EmbeddingService, (c) => __awaiter(this, void 0, void 0, function* () {
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const embeddingsModel = options.embeddings.model;
+            const embeddingsHost = options.embeddings.host;
+            if (options.embeddings.provider === "openai") {
+                const { OpenAIEmbeddingService } = yield Promise.resolve().then(() => __importStar(require("../llm/OpenAIEmbeddingService")));
+                logger.info(`Using OpenAI-compatible embeddings provider at ${embeddingsHost}`);
+                return new OpenAIEmbeddingService({
+                    model: embeddingsModel,
+                    host: embeddingsHost,
+                    apiKey: options.embeddings.apiKey,
+                    maxInputChars: options.embeddings.maxInputChars,
+                }, logger);
+            }
+            const { EmbeddingService } = yield Promise.resolve().then(() => __importStar(require("../llm/EmbeddingService")));
+            return new EmbeddingService({
+                model: embeddingsModel,
+                host: embeddingsHost,
+                maxInputChars: options.embeddings.maxInputChars,
+            }, logger);
+        }));
+        // Register Prompt Manager
+        container.register(exports.TYPES.PromptManager, (c) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const { PromptManager } = yield Promise.resolve().then(() => __importStar(require("../llm/prompts/PromptManager")));
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const manager = new PromptManager(logger, undefined, (_b = (_a = config.processingOptions) === null || _a === void 0 ? void 0 : _a.readers) === null || _b === void 0 ? void 0 : _b.outline);
+            const options = config.processingOptions;
+            if ((_c = options === null || options === void 0 ? void 0 : options.llm) === null || _c === void 0 ? void 0 : _c.promptVersion) {
+                manager.setPromptVersion(options.llm.promptVersion);
+            }
+            if ((_d = options === null || options === void 0 ? void 0 : options.llm) === null || _d === void 0 ? void 0 : _d.system) {
+                manager.setCustomSystemPrompt(options.llm.system);
+            }
+            return manager;
+        }));
+        container.register(exports.TYPES.FileDiscoveryService, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { FileDiscoveryService } = yield Promise.resolve().then(() => __importStar(require("..")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            return new FileDiscoveryService(options, logger);
+        }));
+        container.register(exports.TYPES.TextChunker, (c) => __awaiter(this, void 0, void 0, function* () {
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            return new processor_1.TextChunker({
+                enabled: options.chunking.mode !== "disabled",
+                maxChunkSize: options.chunking.size,
+                overlapSize: options.chunking.overlap,
+            }, logger);
+        }));
+        // Structured-emit adapter registry (data-sink track). Empty by default;
+        // concrete adapters (SQLite, OpenAPI, iCal, …) register here in their own briefs.
+        container.register(exports.TYPES.StructuredAdapterRegistry, (c) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { StructuredAdapterRegistry } = yield Promise.resolve().then(() => __importStar(require("../adapters")));
+            const registry = new StructuredAdapterRegistry();
+            // Concrete adapters register only when enabled (registry stays empty otherwise →
+            // default run unaffected). SQLite is the first (data-sink Class A).
+            const sqliteCfg = (_a = processingOptions.adapters) === null || _a === void 0 ? void 0 : _a.sqlite;
+            if (sqliteCfg === null || sqliteCfg === void 0 ? void 0 : sqliteCfg.enabled) {
+                const { SqliteAdapter } = yield Promise.resolve().then(() => __importStar(require("../adapters/SqliteAdapter")));
+                const logger = yield c.resolve(exports.TYPES.Logger);
+                registry.register(new SqliteAdapter({
+                    extensions: sqliteCfg.extensions,
+                    maxRowsPerTable: sqliteCfg.maxRowsPerTable,
+                    excludeTables: sqliteCfg.excludeTables,
+                }, logger));
+            }
+            return registry;
+        }));
+        // Register File REader Factory
+        container.register(exports.TYPES.FileReaderFactory, (c) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { FileReaderFactory, AudioReader, BinaryReader, ChatExportReader, MarkdownReader, DoclingReader, EmailReader, EpubReader, JupyterReader, LatexReader, MarkerPdfReader, MistralOcrReader, TesseractPdfReader, ChandraPdfReader, HtmlReader, ImageReader, JsonFileReader, OfficeReader, SubtitleReader, TextReader, TranscriptReader, PdfReader, RtfReader } = yield Promise.resolve().then(() => __importStar(require("../processor/readers")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const chunker = yield c.resolve(exports.TYPES.TextChunker);
+            const factory = new FileReaderFactory(logger);
+            // Reference-following and web-fetch both need links extracted, so they
+            // auto-imply internalLinks extraction.
+            const refLinks = options.references.internalLinks.enabled ||
+                options.references.follow.enabled ||
+                options.references.web.enabled;
+            // Citation span-fetch (Phase 2) needs the bibliography extracted to know
+            // what to resolve/fetch, so it auto-implies citation extraction.
+            const refCites = options.references.citations.enabled || options.references.citations.fetch.enabled;
+            // Standard non-PDF readers are always registered; the PDF slot is chosen by
+            // readers.pdfEngine below (first-match-wins, so these win their own formats).
+            factory.registerReader(new RtfReader(chunker, logger));
+            factory.registerReader(new MarkdownReader(chunker, logger, options.readers.stripReferences, refLinks, refCites));
+            factory.registerReader(new HtmlReader(chunker, logger, refLinks));
+            // CV pre-pass object detector (opt-in) — a singleton (loads the model once),
+            // injected into ImageReader; undefined when disabled ⇒ no detection, no cost.
+            const cvDet = options.readers.cv.detection;
+            const objectDetector = cvDet.enabled
+                ? new ObjectDetectionService_1.ObjectDetectionService({
+                    mode: cvDet.mode,
+                    model: cvDet.model,
+                    threshold: cvDet.threshold,
+                    labels: cvDet.labels,
+                    maxObjects: cvDet.maxObjects,
+                    cacheDir: cvDet.cacheDir,
+                    allowRemote: cvDet.allowRemote,
+                }, logger)
+                : undefined;
+            factory.registerReader(new ImageReader(chunker, logger, {
+                exif: options.readers.exif.enabled,
+                c2pa: { enabled: options.readers.c2pa.enabled, command: options.readers.c2pa.command },
+            }, objectDetector));
+            factory.registerReader(new OfficeReader(chunker, logger));
+            // PDF engine selector. The built-in pdf2json reader doubles as the graceful
+            // fallback for the marker/mistral engines (any failure → pdf2json).
+            const pdf2json = new PdfReader(chunker, logger, options.readers.stripReferences, refCites);
+            switch (options.readers.pdfEngine) {
+                case "docling":
+                    logger.info(`PDF engine: docling`);
+                    factory.registerReader(new DoclingReader(undefined, undefined, undefined, "./temp", chunker, logger, [".pdf"]));
+                    break;
+                case "marker": {
+                    const m = options.readers.marker;
+                    logger.info(`PDF engine: marker${m.useLlm ? " (--use_llm)" : ""}`);
+                    factory.registerReader(new MarkerPdfReader({ command: m.command, useLlm: m.useLlm, forceOcr: m.forceOcr, timeoutMs: m.timeoutMs }, { apiKey: options.llm.apiKey, host: options.llm.host, model: options.llm.model }, pdf2json, "./temp", chunker, logger));
+                    break;
+                }
+                case "mistral": {
+                    const mi = options.readers.mistral;
+                    logger.info(`PDF engine: mistral (${mi.model})`);
+                    factory.registerReader(new MistralOcrReader({ apiKey: (_a = mi.apiKey) !== null && _a !== void 0 ? _a : process.env.MISTRAL_API_KEY, host: mi.host, model: mi.model, timeoutMs: mi.timeoutMs }, pdf2json, chunker, logger));
+                    break;
+                }
+                case "tesseract": {
+                    const t = options.readers.tesseract;
+                    logger.info(`PDF engine: tesseract (${t.lang})`);
+                    factory.registerReader(new TesseractPdfReader({ lang: t.lang, scale: t.scale, oem: t.oem, psm: t.psm, langPath: t.langPath }, pdf2json, chunker, logger));
+                    break;
+                }
+                case "chandra": {
+                    const ch = options.readers.chandra;
+                    logger.info(`PDF engine: chandra (${ch.method})`);
+                    factory.registerReader(new ChandraPdfReader({ command: ch.command, method: ch.method, timeoutMs: ch.timeoutMs }, pdf2json, "./temp", chunker, logger));
+                    break;
+                }
+                default:
+                    factory.registerReader(pdf2json);
+            }
+            // Transcript reader claims speaker-labeled text (.parakeet.txt, …) and
+            // transcript-shaped JSON (recua turns / chat exports). Registered before
+            // JsonFileReader and TextReader (first-match-wins) so it wins for those;
+            // its content-sniffing canRead defers everything else.
+            factory.registerReader(new TranscriptReader(chunker, logger, options.chunking.size));
+            // Email reader claims .eml/.mbox (otherwise unclaimed → skipped as binary).
+            // Each message becomes a conversational turn (sender→speaker, Date→occurredAt),
+            // reusing the shared transcript turn-packing. Registered before TextReader.
+            factory.registerReader(new EmailReader(chunker, logger, options.chunking.size, options.readers.email));
+            // Chat-export reader sniffs chat-shaped .txt (WhatsApp) / .json (Telegram,
+            // Discord, Slack) and defers everything else. Registered after Transcript
+            // (Claude/ChatGPT exports stay there) and before Json/Text. Each message
+            // becomes a turn (sender→speaker, timestamp→occurredAt) via packTurns.
+            factory.registerReader(new ChatExportReader(chunker, logger, options.chunking.size, options.readers.chat));
+            // Class C structure-rich text (.srt/.vtt subtitles, .tex LaTeX) — both
+            // currently unclaimed (→ BinaryReader). Subtitles denoise captions (+ <v>
+            // turns); LaTeX cleans the body and feeds \cite{} into the reference
+            // pipeline (refCites) → cites edges. Registered before Text/Binary.
+            factory.registerReader(new SubtitleReader(chunker, logger, options.chunking.size));
+            factory.registerReader(new LatexReader(chunker, logger, refCites));
+            // EPUB (zip→spine→chapter chunking) and Jupyter (cell-aware) — extensions
+            // were unclaimed (→ BinaryReader). Registered before Text/Binary.
+            factory.registerReader(new EpubReader(chunker, logger, options.chunking.size));
+            factory.registerReader(new JupyterReader(chunker, logger, options.readers.jupyter));
+            // JSON reader claims .json/.jsonl/.geojson — must be registered before
+            // TextReader (first-match-wins) so it handles them instead of TextReader.
+            factory.registerReader(new JsonFileReader({
+                strategy: options.readers.json.strategy,
+                maxChunkSize: (_b = options.readers.json.maxChunkSize) !== null && _b !== void 0 ? _b : options.chunking.size,
+            }, chunker, logger));
+            // ASR audio reader before TextReader so audio never falls through to text;
+            // only registered when ASR is enabled (otherwise audio routes to the
+            // BinaryReader catch-all below and is skipped gracefully).
+            if (options.readers.asr.mode !== "disabled") {
+                logger.info(`Using automatic speech recognition pipeline`);
+                const asr = options.readers.asr;
+                if (asr.engine === "dual") {
+                    logger.info(`ASR engine: dual (vendored Python audio-pipeline at ${asr.dual.projectDir})`);
+                }
+                factory.registerReader(new AudioReader({
+                    modelName: asr.whisperModel,
+                    language: asr.language,
+                    translate: asr.translate,
+                    engine: asr.engine,
+                    maxChunkSize: options.chunking.size,
+                    dual: {
+                        projectDir: asr.dual.projectDir,
+                        pythonPath: asr.dual.pythonPath,
+                        asr: asr.dual.asr,
+                        diarize: asr.dual.diarize,
+                        numSpeakers: asr.dual.numSpeakers,
+                        device: asr.dual.device,
+                        timeoutMs: asr.dual.timeoutMs,
+                    },
+                }, "./temp", chunker, logger));
+            }
+            factory.registerReader(new TextReader(chunker, logger));
+            // Final catch-all: claims anything no specific reader recognized and skips
+            // it gracefully (no UTF-8 mojibake, no LLM call). MUST be registered last.
+            factory.registerReader(new BinaryReader(chunker, logger));
+            return factory;
+        }));
+        // Register Content Classifier
+        container.register(exports.TYPES.ContentClassifier, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { HeuristicContentClassifier, CascadeContentClassifier, } = yield Promise.resolve().then(() => __importStar(require("../processor/classifier")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            switch (options.classifier.mode) {
+                case "heuristic":
+                    return new HeuristicContentClassifier(logger, options.classifier.temperature, options.classifier.crossValidationFactor);
+                case "llm": {
+                    // Share the selected generation provider (KG-15) so --classifier llm
+                    // works on cloud (OpenAI-compatible) backends, not just local Ollama.
+                    const llm = yield c.resolve(exports.TYPES.LLMService);
+                    return new LlmContentClassifier_1.LlmContentClassifier(llm, logger);
+                }
+                case "cascade": {
+                    // Phase-B cascade: heuristic decides the easy majority; only top-2 ties
+                    // escalate to the LLM (same shared provider). Degrades to heuristic-multi
+                    // when the budget is spent or the provider is unreachable.
+                    const llm = yield c.resolve(exports.TYPES.LLMService);
+                    return new CascadeContentClassifier(new HeuristicContentClassifier(logger, options.classifier.temperature, options.classifier.crossValidationFactor), new LlmContentClassifier_1.LlmContentClassifier(llm, logger), logger, options.classifier.maxEscalations);
+                }
+                default: return undefined;
+            }
+        }));
+        // Register File Processor
+        container.register(exports.TYPES.FileProcessor, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { FileProcessor } = yield Promise.resolve().then(() => __importStar(require("../processor")));
+            const factory = yield c.resolve(exports.TYPES.FileReaderFactory);
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const classifier = yield c.resolve(exports.TYPES.ContentClassifier);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            return new FileProcessor(factory, classifier, options.readers.images !== "disabled", logger);
+        }));
+        // Register Corpus Analyzer (used only when --corpus-profiling is enabled)
+        container.register(exports.TYPES.CorpusAnalyzer, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { CorpusAnalyzer } = yield Promise.resolve().then(() => __importStar(require("../corpus")));
+            const llmService = yield c.resolve(exports.TYPES.LLMService);
+            const classifier = yield c.resolve(exports.TYPES.ContentClassifier);
+            const factory = yield c.resolve(exports.TYPES.FileReaderFactory);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const promptManager = yield c.resolve(exports.TYPES.PromptManager);
+            return new CorpusAnalyzer(llmService, classifier, factory, logger, promptManager);
+        }));
+        // Register the AST symbol seed service (Phase 8; used when ast.mode=enabled)
+        container.register(exports.TYPES.AstSeedService, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { AstSeedService, AstSymbolStore } = yield Promise.resolve().then(() => __importStar(require("../processor/ast")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const cachePath = options.ast.cachePath || `${options.output}.ast-cache.json`;
+            const store = new AstSymbolStore(cachePath, logger);
+            return new AstSeedService(store, logger, options.input);
+        }));
+        // Register the web reference fetch cache + gated fetcher (Phase 1; used only
+        // when references.web.enabled). Network layer is never constructed otherwise.
+        container.register(exports.TYPES.FetchCacheService, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { FetchCacheService } = yield Promise.resolve().then(() => __importStar(require("../knowledge/references/web/FetchCacheService")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const cachePath = options.references.web.cachePath || `${options.output}.fetch-cache.jsonl`;
+            const cache = new FetchCacheService(cachePath, logger);
+            yield cache.load();
+            return cache;
+        }));
+        container.register(exports.TYPES.GatedFetcher, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { GatedFetcher } = yield Promise.resolve().then(() => __importStar(require("../knowledge/references/web/GatedFetcher")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const llm = yield c.resolve(exports.TYPES.LLMService);
+            const w = options.references.web;
+            return new GatedFetcher({
+                allowlist: w.allowlist,
+                rejectlist: w.rejectlist,
+                maxFetches: w.maxFetches,
+                timeoutMs: w.timeoutMs,
+                maxBytes: w.maxBytes,
+                relevanceCheck: w.relevanceCheck,
+                robots: w.robots,
+            }, llm, logger);
+        }));
+        // Phase 2 — citation span-fetch services. Constructed only when
+        // references.citations.fetch.enabled; a default run never builds them.
+        container.register(exports.TYPES.CitationFetchCache, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { FetchCacheService } = yield Promise.resolve().then(() => __importStar(require("../knowledge/references/web/FetchCacheService")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const cachePath = options.references.citations.fetch.cachePath || `${options.output}.citation-cache.jsonl`;
+            const cache = new FetchCacheService(cachePath, logger);
+            yield cache.load();
+            return cache;
+        }));
+        container.register(exports.TYPES.CitationFetcher, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { GatedFetcher } = yield Promise.resolve().then(() => __importStar(require("../knowledge/references/web/GatedFetcher")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const llm = yield c.resolve(exports.TYPES.LLMService);
+            const f = options.references.citations.fetch;
+            return new GatedFetcher({
+                allowlist: f.allowlist,
+                rejectlist: f.rejectlist,
+                maxFetches: f.maxFetches,
+                timeoutMs: f.timeoutMs,
+                maxBytes: f.maxBytes,
+                relevanceCheck: false, // OA full text — the allowlist is the gate
+                robots: true,
+                allowPdf: true,
+            }, llm, logger);
+        }));
+        container.register(exports.TYPES.CitationResolver, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { CitationResolver } = yield Promise.resolve().then(() => __importStar(require("../knowledge/references/citations/CitationResolver")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const cfg = options.references.citations;
+            let titleResolver = null;
+            if (cfg.titleResolver.enabled) {
+                const { TitleIdResolver } = yield Promise.resolve().then(() => __importStar(require("../knowledge/references/citations/TitleIdResolver")));
+                const t = cfg.titleResolver;
+                titleResolver = new TitleIdResolver({
+                    mailto: t.mailto,
+                    openAlexKey: t.openAlexKey,
+                    semanticScholarKey: t.semanticScholarKey,
+                    minTitleSimilarity: t.minTitleSimilarity,
+                }, logger);
+            }
+            const unpaywallEmail = cfg.fetch.unpaywallEmail || process.env.UNPAYWALL_EMAIL;
+            return new CitationResolver({ unpaywallEmail }, logger, titleResolver);
+        }));
+        container.register(exports.TYPES.GrobidClient, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { GrobidClient } = yield Promise.resolve().then(() => __importStar(require("../knowledge/references/citations/GrobidClient")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            return new GrobidClient(options.references.citations.grobid.url, logger);
+        }));
+        // Register Checkpoint service (used only when --resume is set)
+        container.register(exports.TYPES.CheckpointService, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { CheckpointService } = yield Promise.resolve().then(() => __importStar(require("../checkpoint")));
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const checkpointPath = options.resume.checkpointPath || `${options.output}.checkpoint.jsonl`;
+            const service = new CheckpointService(checkpointPath, logger, {
+                model: options.llm.model,
+                promptVersion: options.llm.promptVersion,
+            });
+            if (options.resume.enabled) {
+                yield service.load();
+            }
+            return service;
+        }));
+        // Register Knowledge Graph Builder
+        container.register(exports.TYPES.KnowledgeGraphBuilder, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { KnowledgeGraphBuilder } = yield Promise.resolve().then(() => __importStar(require("../knowledge/KnowledgeGraphBuilder")));
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const llmService = yield c.resolve(exports.TYPES.LLMService);
+            const promptManager = yield c.resolve(exports.TYPES.PromptManager);
+            const checkpoint = yield c.resolve(exports.TYPES.CheckpointService);
+            const progress = yield c.resolve(exports.TYPES.ProgressEmitter);
+            // Inline grounding checker: minicheck (local NLI, with keyword pre-filter)
+            // when selected & active; otherwise the builder defaults to the keyword
+            // checker. The grounding signature is folded into the checkpoint key so
+            // toggling the gate between --resume runs re-extracts affected chunks
+            // (disabled ⇒ empty signature == legacy key, preserving old checkpoints).
+            const g = options.grounding;
+            const groundingSignature = g.mode === "disabled" ? "" : `${g.mode}|${g.checker}|${g.minScore}|${g.model}`;
+            let groundingChecker;
+            if (g.mode !== "disabled" && g.checker === "minicheck") {
+                const { MiniCheckGroundingChecker } = yield Promise.resolve().then(() => __importStar(require("../knowledge/grounding")));
+                groundingChecker = new MiniCheckGroundingChecker({ model: g.model, host: g.host, min: g.minScore, escalateAbove: g.escalateAbove }, logger);
+            }
+            return new KnowledgeGraphBuilder({
+                llmService,
+                promptManager: promptManager,
+                checkpoint,
+                resume: options.resume.enabled,
+                model: options.llm.model,
+                promptVersion: options.llm.promptVersion,
+                inputRoot: options.input,
+                progress,
+                grounding: options.grounding.mode,
+                groundingMinScore: options.grounding.minScore,
+                groundingChecker,
+                groundingSignature,
+                // Stamp edge source spans only when the pipeline grounding gate needs
+                // them, so the baseline graph stays free of the extra weight.
+                attachSourceSpans: options.pipeline.grounding.enabled,
+                // Free-vocabulary extraction (canonicalization-tax measurement): drops the
+                // closed entity/relation enum so the model emits any predicate/type.
+                openPredicate: options.pipeline.extraction.openPredicate,
+                // Strict closed vocabulary: a supplied glossary REPLACES (not augments) the
+                // base/domain vocab — feed a known ontology as the authoritative schema.
+                strictVocabulary: options.pipeline.extraction.strictVocabulary,
+            }, logger);
+        }));
+        // Register Knowledge Graph Search
+        container.register(exports.TYPES.KnowledgeGraphSearch, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { KnowledgeGraphSearch } = yield Promise.resolve().then(() => __importStar(require("../knowledge")));
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const embeddingService = yield c.resolve(exports.TYPES.EmbeddingService);
+            return new KnowledgeGraphSearch(embeddingService, logger);
+        }));
+        // Register Knowledge Graph Merger
+        container.register(exports.TYPES.KnowledgeGraphMerger, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { mergeKnowledgeGraphs } = yield Promise.resolve().then(() => __importStar(require("../knowledge")));
+            const logger = yield c.resolve(exports.TYPES.Logger);
+            const options = yield c.resolve(exports.TYPES.ProcessingOptions);
+            const embeddingService = yield c.resolve(exports.TYPES.EmbeddingService);
+            // Merge-time supersession checker (KG-10): heuristic (cheap, default off) or
+            // LLM-backed; off ⇒ no supersession. The LLM checker reuses the generation
+            // provider (resolved lazily so a heuristic/disabled run needs no LLM).
+            let contradictionChecker;
+            if (options.merging.supersession === "heuristic") {
+                const { HeuristicContradictionChecker } = yield Promise.resolve().then(() => __importStar(require("../knowledge/contradiction")));
+                contradictionChecker = new HeuristicContradictionChecker();
+            }
+            else if (options.merging.supersession === "llm") {
+                const { LlmContradictionChecker } = yield Promise.resolve().then(() => __importStar(require("../knowledge/contradiction")));
+                const llm = yield c.resolve(exports.TYPES.LLMService);
+                contradictionChecker = new LlmContradictionChecker(llm, logger);
+            }
+            // Return a wrapper that implements the interface
+            return {
+                merge: (graphs) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const records = [];
+                    const wantMergeLog = options.inspection.emitMergeLog;
+                    // The merge-log seam doubles as the trace merge-decision source: fold each
+                    // non-canonical surface form's mentions onto the winner (lineage thread)
+                    // and emit one merge_decision event per fusion.
+                    const onMergeRecord = wantMergeLog || trace_1.trace.enabled
+                        ? (r) => {
+                            var _a;
+                            if (wantMergeLog)
+                                records.push(r);
+                            if (trace_1.trace.enabled) {
+                                const foldedMentionIds = [];
+                                for (const sf of r.surface_forms) {
+                                    if (sf === r.canonical_chosen)
+                                        continue;
+                                    foldedMentionIds.push(...trace_1.trace.lineage.fold(sf, r.canonical_chosen).map((m) => m.mentionId));
+                                }
+                                trace_1.trace.emit({
+                                    stage: "merge",
+                                    type: "merge_decision",
+                                    mergeDecisionId: r.cluster_id,
+                                    target: r.target,
+                                    canonical: r.canonical_chosen,
+                                    surfaceForms: r.surface_forms,
+                                    foldedMentionIds,
+                                    cosine: (_a = r.intra_cluster_sim) === null || _a === void 0 ? void 0 : _a.max,
+                                    method: r.method,
+                                    verdict: "accept",
+                                });
+                            }
+                        }
+                        : undefined;
+                    const result = yield mergeKnowledgeGraphs(graphs, {
+                        entitySimilarityThreshold: options.merging.entitySimilarityThreshold,
+                        observationSimilarityThreshold: options.merging.observationSimilarityThreshold,
+                        enableSimilarityMerging: options.merging.enableSimilarityMerging,
+                        contradictionChecker,
+                        onMergeRecord,
+                    }, embeddingService, logger);
+                    // String-merge fusions land next to the canon merge log (same JSONL shape,
+                    // readable by `wanshi inspect-merges`).
+                    if (options.inspection.emitMergeLog && records.length > 0) {
+                        const path = yield Promise.resolve().then(() => __importStar(require("path")));
+                        const fs = yield Promise.resolve().then(() => __importStar(require("fs")));
+                        const base = (_a = options.inspection.mergeLogPath) !== null && _a !== void 0 ? _a : path.join("runs", new Date().toISOString().replace(/[:.]/g, "-"), "merges.jsonl");
+                        const logPath = path.join(path.dirname(base), "string-merges.jsonl");
+                        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+                        fs.writeFileSync(logPath, records.map((r) => JSON.stringify(r)).join("\n") + "\n");
+                        logger.info(`String-merge log written to ${logPath} (${records.length} fusion(s))`);
+                    }
+                    return result;
+                }),
+            };
+        }));
+        // Register Knowledge Graph Export Service
+        container.register(exports.TYPES.KnowledgeGraphExportService, () => __awaiter(this, void 0, void 0, function* () {
+            const { JsonExportStrategy, JsonlExportStrategy, McpExportStrategy, GraphvizDotExportStrategy, KblamExportStrategy, LoraExportStrategy, GraphitiExportStrategy, } = yield Promise.resolve().then(() => __importStar(require("../export/strategies")));
+            const { KnowledgeGraphExportService } = yield Promise.resolve().then(() => __importStar(require("../export/KnowledgeGraphExportService")));
+            return new KnowledgeGraphExportService(new JsonExportStrategy(), new JsonlExportStrategy(), new McpExportStrategy(), new GraphvizDotExportStrategy(), new KblamExportStrategy(), new LoraExportStrategy(), new GraphitiExportStrategy());
+        }));
+        // Register Directory Processor (depends on all other services)
+        container.register(exports.TYPES.DirectoryProcessor, (c) => __awaiter(this, void 0, void 0, function* () {
+            const { DirectoryProcessor } = yield Promise.resolve().then(() => __importStar(require("../DirectoryProcessor")));
+            return new DirectoryProcessor(c);
+        }));
+        return container;
+    }
+}
+exports.ContainerFactory = ContainerFactory;
+//# sourceMappingURL=ContainerFactory.js.map