@wanshi-kg/wanshi 0.1.0

package/dist/core/llm/prompts/templates/v4/user.hbs

@@ -0,0 +1,40 @@
+## File Information
+
+{{#if filePath}}Path: {{filePath}}{{/if}}
+{{#if totalChunks}}Chunk: {{chunkIndex}} of {{totalChunks}}{{/if}}
+{{#if fileOutline}}
+
+{{#if metadata}}
+## File Metadata
+
+
+{{/if}}
+
+## Document Outline
+
+```
+{{fileOutline}}
+```
+{{/if}}
+
+{{#if retrievedEntities}}
+## Existing Knowledge Context
+
+Entities already extracted from other parts of this project (do NOT copy them — only reference or extend them):
+
+{{#each retrievedEntities}}
+- **{{name}}** ({{entityType}}): {{truncate (join observations "; ") 200}}
+{{/each}}
+{{/if}}
+
+{{#if domainHints}}
+## Domain Context
+
+{{domainHints}}
+
+{{/if}}
+## Content to Analyze
+
+```
+{{#if chunkContent}}{{chunkContent}}{{else}}{{fileContent}}{{/if}}
+```

package/dist/core/llm/prompts/templates/v4.5/system.hbs

@@ -0,0 +1,71 @@
+# Expert Knowledge Graph Generation System
+
+## MISSION STATEMENT
+
+You are an expert data analyst and knowledge extraction AI system. Your mission is to transform unstructured content from files into structured knowledge graphs that capture **meaningful** entities, relationships, and observations. Extract **specific** entities, relations, and observations from provided text/code/documentation/image content achieving over 90% factual accuracy.
+
+## WORKING DIRECTORY CONTEXT
+
+**Root Directory:** `{{inputDirectory}}`
+**File Filter:** `{{filter}}`
+{{#if directoryTree}}
+**Directory Structure (filtered):**
+
+```
+{{directoryTree}}
+```
+
+Use this directory structure to understand file relationships, project organization, and contextual connections between entities.
+{{#if userDescription}}
+User provided following description of files in the working directory: 
+```
+{{userDescription}}
+```
+
+{{/if}}
+{{/if}}
+## OUTPUT SCHEMA
+
+You **MUST** output a valid JSON following this exact schema:
+
+```json
+{
+  "entities": [
+    {
+      "name": "unique_identifier",
+      "entityType": "person|organization|technology|concept|method|function|class|module|file|error|event|standard|protocol|algorithm|data_structure|etc",
+      "observations": ["meaningful_fact_1", "meaningful_fact_2", "..."]
+    }
+  ],
+  "relations": [
+    {
+      "from": "entity_name",
+      "to": "entity_name", 
+      "relationType": ["relationship_type_1", "relationship_type_2", "..."]
+    }
+  ]
+}
+```
+
+## EXTRACTION INSTRUCTIONS
+
+Given a text, extract:
+
+1. **Entities** — named things (people, places, organizations, concepts, events, products, etc.)
+   - name: short canonical identifier
+   - entityType: category (person, organization, location, concept, event, product, ...)
+   - observations: factual statements about the entity found in the text
+
+2. **Relations** — directed connections between entities
+   - from: source entity name (must match an entity name exactly)
+   - to: target entity name (must match an entity name exactly)
+   - relationType: one or more short relation labels, e.g. ["works_at"] or ["founded", "leads"]
+
+Rules:
+- Only extract information explicitly stated in the text.
+- Entity names used in relations must exactly match names in the entities list.
+- Omit anything you are not confident about.
+
+## FINAL REMINDER
+
+Your success is measured by the **meaningfulness and accuracy** of extracted knowledge. When in doubt, prefer returning an empty graph over including trivial or hallucinated information. Focus on entities and relationships that would be valuable to a knowledge worker trying to understand the codebase, project, or domain.

package/dist/core/llm/prompts/templates/v4.5/user.hbs

@@ -0,0 +1,46 @@
+## File Information
+
+{{#if filePath}}Path: {{filePath}}{{/if}}
+{{#if totalChunks}}Chunk: {{chunkIndex}} of {{totalChunks}}{{/if}}
+{{#if fileOutline}}
+
+{{#if metadata}}
+## File Metadata
+
+
+{{/if}}
+
+## Document Outline
+
+```
+{{fileOutline}}
+```
+{{/if}}
+
+{{#if retrievedEntities}}
+## Existing Knowledge Context
+
+Entities already extracted from other parts of this project (do NOT copy them — only reference or extend them):
+
+{{#each retrievedEntities}}
+- **{{name}}** ({{entityType}}): {{truncate (join observations "; ") 200}}
+{{/each}}
+{{/if}}
+
+{{#if domainHints}}
+## Domain Context
+
+{{domainHints}}
+
+{{/if}}
+{{#if corpusGlossary}}
+## Corpus Glossary
+
+{{corpusGlossary}}
+
+{{/if}}
+## Content to Analyze
+
+```
+{{#if chunkContent}}{{chunkContent}}{{else}}{{fileContent}}{{/if}}
+```

package/dist/core/llm/prompts/templates/v5/glossary/system.hbs

@@ -0,0 +1,40 @@
+You design the controlled vocabulary for knowledge-graph extraction over a
+document corpus. Extraction runs file-by-file; without a shared vocabulary each
+file invents its own entity types and relation predicates, and the merged graph
+fragments into hundreds of one-off types. Your job is to prevent that by fixing a
+small, canonical vocabulary up front.
+
+You are given the corpus's dominant content type, its most frequent terms, and a
+few representative snippets. Produce three lists:
+
+1. **entityNames** — the real recurring proper nouns and key concepts in this
+   corpus, each normalized to ONE canonical spelling. Only include names that
+   genuinely recur or anchor the domain; skip incidental mentions. A few dozen at
+   most.
+
+2. **entityTypes** — the categories that fit this corpus. Keep this SMALL and
+   reusable: aim for 8–20 types that cover the corpus, not one type per concept.
+   Lowercase `snake_case`. Prefer a slightly-general type that applies broadly
+   (`function`) over a narrow one that applies once (`cli_argument_parser`).
+
+3. **relationTypes** — the predicates that connect entities in this corpus.
+   Lowercase `snake_case`, each a single verb-like predicate (`depends_on`, not
+   `uses,depends_on`). Keep it small — 6–15. Include `related_to` as a catch-all.
+
+Guidance:
+- Prefer terms that actually appear in the corpus over generic ontology labels.
+- Every type and predicate you list will be enforced as a closed set during
+  extraction, so omit anything speculative — a missing type is recoverable, a
+  bloated list defeats the purpose.
+- Choose canonical spellings deliberately: one casing convention, no synonyms
+  (pick `organization` xor `org`, not both).
+
+Return JSON only, in exactly this shape:
+
+```json
+{
+  "entityNames": ["...", "..."],
+  "entityTypes": ["...", "..."],
+  "relationTypes": ["...", "..."]
+}
+```

package/dist/core/llm/prompts/templates/v5/glossary/user.hbs

@@ -0,0 +1,11 @@
+Corpus content type: {{classLine}}
+
+Most frequent terms (with counts):
+```
+{{termList}}
+```
+
+Representative snippets:
+```
+{{snippets}}
+```

package/dist/core/llm/prompts/templates/v5/system.hbs

@@ -0,0 +1,163 @@
+# Knowledge Graph Extraction
+
+You extract a knowledge graph from one file (or one chunk of a file). The graph
+feeds downstream retrieval and knowledge-injection systems, so it must be
+*consistent* across files, not just locally plausible: the same concept gets the
+same name and the same type everywhere, and relations point in a predictable
+direction. A locally pretty graph that uses a fresh entity type for every node is
+useless once merged.
+
+## Output schema
+
+Return one valid JSON object, nothing else — no prose, no markdown fences:
+
+```json
+{
+  "entities": [
+    { "name": "...", "entityType": "...", "observations": ["...", "..."] }
+  ],
+  "relations": [
+    { "from": "...", "to": "...", "relationType": ["..."] }
+  ]
+}
+```
+
+- `name` — the canonical identifier for the thing. One spelling per concept.
+- `entityType` — a single category drawn from the controlled vocabulary below.
+- `observations` — short factual statements about the entity, each grounded in
+  the content. Not a restatement of the type.
+- `relations[].from` / `to` — each must name a real entity: either one you emit
+  in `entities`, or one already established in the provided context (the *Already
+  extracted* list or the corpus vocabulary), which you reference by its canonical
+  name **without** re-emitting it. Never invent an endpoint that names neither.
+- `relationType` — an array holding **one** canonical predicate. Use a single
+  predicate per edge; do not stack synonyms.
+
+If the content carries no extractable knowledge (empty, binary garbage, a stray
+fragment), return `{"entities": [], "relations": []}`. An empty graph is a correct
+answer, not a failure.
+
+## Working directory context
+
+**Root:** `{{inputDirectory}}`
+**Filter:** `{{filter}}`
+{{#if directoryTree}}
+**Structure (filtered):**
+
+```
+{{directoryTree}}
+```
+
+Use this to resolve what a file *is* and how it relates to its neighbors — e.g. a
+file under `readers/` that imports a base class is a reader implementation, not a
+free-floating module.
+{{#if userDescription}}
+
+User's description of the working directory:
+```
+{{userDescription}}
+```
+{{/if}}
+{{/if}}
+
+## Controlled vocabularies
+
+{{#if openVocabulary}}
+**No fixed vocabulary.** For each entity choose the most natural type, and for each
+relation the single most precise predicate that names what the text says — use the
+exact verb/relationship the sentence implies (`feeds_on`, `becomes`,
+`lays_eggs_on`, `regulates`, …). All lowercase `snake_case`. Always prefer a
+specific predicate; **never** fall back to a generic `related_to`.
+{{else}}
+{{#if entityTypeVocabulary}}
+**Entity types — use these and only these.** If an entity does not fit any of
+them, choose the closest fit. Coining a new type fragments the merged graph, so
+treat it as a last resort, and when you must, use lowercase `snake_case`.
+
+```
+{{entityTypeVocabulary}}
+```
+{{else}}
+**Entity types.** Prefer this base set; reach for a new type only when nothing
+here fits, and write it lowercase `snake_case`. A slightly-too-general type that
+is reused beats a perfect type that appears once.
+
+```
+person, organization, location, role, event, time, metric,
+concept, term, document, product, technology, standard,
+class, interface, function, module, service, dependency,
+data_structure, config, file
+```
+{{/if}}
+
+{{#if relationTypeVocabulary}}
+**Relation predicates — use these and only these.** Pick the single best fit. If
+none fits, use `related_to` rather than inventing a predicate.
+
+```
+{{relationTypeVocabulary}}
+```
+{{else}}
+**Relation predicates.** Pick the single best fit from this base set; fall back to
+`related_to` rather than inventing one. All lowercase `snake_case`.
+
+```
+uses, depends_on, calls, implements, extends, contains, part_of,
+produces, consumes, configures, references, defines, targets,
+located_in, works_at, member_of, precedes, causes, has_attribute,
+related_to
+```
+{{/if}}
+{{/if}}
+
+## Extraction rules
+
+**Entities — extract the things that carry meaning.** Functions, classes,
+services, people, organizations, named concepts, products, standards. One node
+per real-world concept: if two surface strings mean the same thing, merge them
+under one canonical name; if one surface string means two different things in
+different contexts (e.g. `Node` the runtime vs `Node` a tree element), keep them
+distinct by qualifying the name (`node_runtime`, `tree_node`).
+
+**Names:** preserve real identifiers exactly as written — a function
+`processFiles` or class `AuthService` keeps its casing, because the name is the
+join key that links this entity across files. Use lowercase `snake_case` only for
+abstract concepts that have no canonical symbol (`spike_detection`, `rate_limiting`).
+Preserve spelling and casing for proper nouns (people, orgs, places, products).
+Never put a file path or chunk number in a name or an observation.
+
+**Don't extract:** language keywords, primitive types, literal values (a dollar
+amount, a timestamp, a single number) as standalone entities, or syntax. A value
+belongs *inside* an observation on the entity it describes — `"$45M Series B
+raised Jan 2024"` is an observation on a company, not a node named `$45M`.
+
+**Observations** state something the content actually says and that the type
+doesn't already imply. `entityType: function` + observation `"a function"` is
+zero information. Good: what it does, what it takes, what it returns, a measured
+value, a constraint.
+
+**Relations are directed and canonical.**
+- One predicate per edge, from the vocabulary.
+- Choose a consistent direction: actor → object, specific → general, caller →
+  callee (`order_service uses database`, not the reverse).
+- No self-loops. `from` and `to` must differ.
+- Don't assert both `A → B` and `B → A` for the same relationship; pick the one
+  canonical direction.
+- Link across files. An endpoint may be an entity established elsewhere in the
+  corpus (from the provided context) — pointing this file's relations at those
+  names is the *purpose* of that context, not a violation. The only forbidden
+  endpoint is a name that exists nowhere.
+- Only connect entities when the content supports the link. A weak or guessed
+  edge is worse than no edge.
+
+**Ground everything in the provided content.** Do not import outside knowledge,
+and do not infer facts the text doesn't state. When unsure, leave it out.
+
+{{#if domainExamples}}
+## Worked examples for this content type ({{detectedContentClass}})
+
+Follow the entity granularity, naming, type reuse, and single-predicate relations
+shown here.
+
+{{domainExamples}}
+{{/if}}

package/dist/core/llm/prompts/templates/v5/user.hbs

@@ -0,0 +1,55 @@
+## File information
+
+{{#if filePath}}Path: `{{filePath}}`{{/if}}
+{{#if totalChunks}}Chunk {{chunkIndex}} of {{totalChunks}}{{/if}}
+
+{{#if metadata}}
+## File metadata
+
+```
+{{metadata}}
+```
+{{/if}}
+
+{{#if fileOutline}}
+## Document outline
+
+```
+{{fileOutline}}
+```
+{{/if}}
+
+{{#if corpusGlossary}}
+## Corpus vocabulary (authoritative)
+
+These entity names, types, and relation predicates have already been established
+across this corpus. Reuse them exactly. When something you find matches one of
+these, use the established spelling and type rather than coining your own.
+
+{{corpusGlossary}}
+{{/if}}
+
+{{#if retrievedEntities}}
+## Already extracted (do not re-emit)
+
+These entities exist from other files. Do **not** copy them into your output. You
+may extend them only by emitting an entity with the *same canonical name* carrying
+a genuinely new observation from this file; otherwise leave them out and just point
+relations at them by name.
+
+{{#each retrievedEntities}}
+- **{{name}}** ({{entityType}}): {{truncate (join observations "; ") 200}}
+{{/each}}
+{{/if}}
+
+{{#if domainHints}}
+## Domain context
+
+{{domainHints}}
+{{/if}}
+
+## Content to analyze
+
+```
+{{#if chunkContent}}{{chunkContent}}{{else}}{{fileContent}}{{/if}}
+```

package/dist/core/pipeline/GroundingTransform.js

@@ -0,0 +1,52 @@
+"use strict";
+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.GroundingTransform = void 0;
+/**
+ * Edge co-occurrence grounding gate (canon brief §6). Drops relations whose two
+ * endpoints don't both appear in the source span the edge was extracted from —
+ * a cheap precision gate for high-recall/low-precision extraction.
+ *
+ * This is a SEAM: OFF for Experiment 1 (schema-first extraction already has
+ * implicit garbage suppression). It exists and is tested now so Experiment 2 is
+ * a flag flip — there it must run BEFORE canonicalization, or canon canonicalizes
+ * junk. Edges only carry `sourceSpan` when `pipeline.grounding.enabled` was set
+ * during extraction (see KnowledgeGraphBuilder.toGraph); without a span we keep
+ * the edge (conservative — can't judge what we can't see).
+ */
+class GroundingTransform {
+    constructor() {
+        this.stage = "grounding";
+    }
+    isEnabled(ctx) {
+        return ctx.options.pipeline.grounding.enabled;
+    }
+    apply(graph, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!ctx.options.pipeline.grounding.requireCooccurrence)
+                return graph;
+            const before = graph.relations.length;
+            const relations = graph.relations.filter((r) => {
+                if (!r.sourceSpan)
+                    return true; // no span → can't judge → keep
+                const span = r.sourceSpan.toLowerCase();
+                return (span.includes(r.from.toLowerCase()) && span.includes(r.to.toLowerCase()));
+            });
+            const dropped = before - relations.length;
+            if (dropped > 0) {
+                ctx.logger.info(`Grounding gate dropped ${dropped}/${before} edge(s) whose endpoints don't co-occur in their source span`);
+            }
+            return { entities: graph.entities, relations };
+        });
+    }
+}
+exports.GroundingTransform = GroundingTransform;
+//# sourceMappingURL=GroundingTransform.js.map

package/dist/core/pipeline/GroundingTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroundingTransform.js","sourceRoot":"","sources":["../../../src/core/pipeline/GroundingTransform.ts"],"names":[],"mappings":";;;;;;;;;;;;AAGA;;;;;;;;;;;GAWG;AACH,MAAa,kBAAkB;IAA/B;QACW,UAAK,GAAG,WAAW,CAAC;IA0B/B,CAAC;IAxBC,SAAS,CAAC,GAAqB;QAC7B,OAAO,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC;IAChD,CAAC;IAEK,KAAK,CAAC,KAAqB,EAAE,GAAqB;;YACtD,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,mBAAmB;gBAAE,OAAO,KAAK,CAAC;YAEtE,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC;YACtC,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC7C,IAAI,CAAC,CAAC,CAAC,UAAU;oBAAE,OAAO,IAAI,CAAC,CAAC,+BAA+B;gBAC/D,MAAM,IAAI,GAAG,CAAC,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;gBACxC,OAAO,CACL,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,EAAE,CAAC,CACzE,CAAC;YACJ,CAAC,CAAC,CAAC;YAEH,MAAM,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;YAC1C,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;gBAChB,GAAG,CAAC,MAAM,CAAC,IAAI,CACb,0BAA0B,OAAO,IAAI,MAAM,8DAA8D,CAC1G,CAAC;YACJ,CAAC;YACD,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC;QACjD,CAAC;KAAA;CACF;AA3BD,gDA2BC"}

package/dist/core/pipeline/PipelineRunner.js

@@ -0,0 +1,51 @@
+"use strict";
+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.PipelineRunner = exports.TRANSFORM_STAGES = void 0;
+/** Stage tokens that resolve to post-extraction graph→graph transforms. */
+exports.TRANSFORM_STAGES = ["grounding", "canonicalization"];
+/**
+ * Runs the enabled graph→graph transforms in the order given by
+ * `pipeline.stages`. Producer tokens (tf_analysis / schema_induction /
+ * extraction) and unknown tokens are skipped here — they're handled (or ignored)
+ * upstream. Reordering `pipeline.stages` reorders the transforms (the seam
+ * Experiment 2 needs: grounding before canonicalization).
+ */
+class PipelineRunner {
+    constructor(transforms, ctx) {
+        this.transforms = transforms;
+        this.ctx = ctx;
+    }
+    /** True when at least one registered transform is enabled by the config. */
+    hasWork() {
+        return this.transforms.some((t) => t.isEnabled(this.ctx));
+    }
+    run(graph) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const byStage = new Map(this.transforms.map((t) => [t.stage, t]));
+            let current = graph;
+            for (const token of this.ctx.options.pipeline.stages) {
+                const transform = byStage.get(token);
+                if (!transform)
+                    continue; // producer/unknown stage — not our concern here
+                if (!transform.isEnabled(this.ctx)) {
+                    this.ctx.logger.debug(`Pipeline stage '${token}' disabled — skipping`);
+                    continue;
+                }
+                this.ctx.logger.info(`Pipeline stage '${token}' running`);
+                current = yield transform.apply(current, this.ctx);
+            }
+            return current;
+        });
+    }
+}
+exports.PipelineRunner = PipelineRunner;
+//# sourceMappingURL=PipelineRunner.js.map

package/dist/core/pipeline/PipelineRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PipelineRunner.js","sourceRoot":"","sources":["../../../src/core/pipeline/PipelineRunner.ts"],"names":[],"mappings":";;;;;;;;;;;;AAgCA,2EAA2E;AAC9D,QAAA,gBAAgB,GAAG,CAAC,WAAW,EAAE,kBAAkB,CAAU,CAAC;AAE3E;;;;;;GAMG;AACH,MAAa,cAAc;IACzB,YACU,UAA4B,EAC5B,GAAqB;QADrB,eAAU,GAAV,UAAU,CAAkB;QAC5B,QAAG,GAAH,GAAG,CAAkB;IAC5B,CAAC;IAEJ,4EAA4E;IAC5E,OAAO;QACL,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5D,CAAC;IAEK,GAAG,CAAC,KAAqB;;YAC7B,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAClE,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACrD,MAAM,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACrC,IAAI,CAAC,SAAS;oBAAE,SAAS,CAAC,gDAAgD;gBAC1E,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;oBACnC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,mBAAmB,KAAK,uBAAuB,CAAC,CAAC;oBACvE,SAAS;gBACX,CAAC;gBACD,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,KAAK,WAAW,CAAC,CAAC;gBAC1D,OAAO,GAAG,MAAM,SAAS,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;YACrD,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;KAAA;CACF;AA1BD,wCA0BC"}

package/dist/core/pipeline/RelationFilterTransform.js

@@ -0,0 +1,72 @@
+"use strict";
+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.RelationFilterTransform = void 0;
+/** True when an edge's predicate set is purely the `related_to` catch-all. */
+function isRelatedToOnly(r) {
+    const types = Array.isArray(r.relationType) ? r.relationType : [r.relationType];
+    return types.length > 0 && types.every((t) => t === "related_to");
+}
+const pairKey = (a, b) => `${a}␟${b}`;
+/**
+ * `related_to` pruning gate (canon brief / NR-4). `related_to` is the relation
+ * layer's catch-all — on prose corpora it's a large, low-value fraction. This runs
+ * AFTER canonicalization (so endpoint names are already canonical) and prunes per
+ * `pipeline.relationFilter.mode`:
+ *   - off       (default) — no change
+ *   - redundant — drop a `related_to` edge only when the same unordered endpoint pair
+ *                 already carries a typed (non-`related_to`) edge: pure redundancy, no
+ *                 information lost.
+ *   - all       — drop every `related_to` edge (for consumers wanting typed-only graphs).
+ *
+ * Re-typing ungrounded `related_to` edges to real predicates needs an LLM pass and is
+ * intentionally out of scope here (a future mode).
+ */
+class RelationFilterTransform {
+    constructor() {
+        this.stage = "relationFilter";
+    }
+    isEnabled(ctx) {
+        return ctx.options.pipeline.relationFilter.mode !== "off";
+    }
+    apply(graph, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const mode = ctx.options.pipeline.relationFilter.mode;
+            if (mode === "off")
+                return graph;
+            // Unordered endpoint pairs that carry at least one typed edge.
+            const typedPairs = new Set();
+            if (mode === "redundant") {
+                for (const r of graph.relations) {
+                    if (isRelatedToOnly(r))
+                        continue;
+                    typedPairs.add(pairKey(r.from, r.to));
+                    typedPairs.add(pairKey(r.to, r.from));
+                }
+            }
+            const before = graph.relations.length;
+            const relations = graph.relations.filter((r) => {
+                if (!isRelatedToOnly(r))
+                    return true;
+                if (mode === "all")
+                    return false;
+                return !typedPairs.has(pairKey(r.from, r.to)); // redundant: keep only if no typed twin
+            });
+            const dropped = before - relations.length;
+            if (dropped > 0) {
+                ctx.logger.info(`Relation filter (${mode}) dropped ${dropped}/${before} 'related_to' edge(s)`);
+            }
+            return { entities: graph.entities, relations };
+        });
+    }
+}
+exports.RelationFilterTransform = RelationFilterTransform;
+//# sourceMappingURL=RelationFilterTransform.js.map

package/dist/core/pipeline/RelationFilterTransform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RelationFilterTransform.js","sourceRoot":"","sources":["../../../src/core/pipeline/RelationFilterTransform.ts"],"names":[],"mappings":";;;;;;;;;;;;AAGA,8EAA8E;AAC9E,SAAS,eAAe,CAAC,CAAW;IAClC,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;IAChF,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC;AACpE,CAAC;AAED,MAAM,OAAO,GAAG,CAAC,CAAS,EAAE,CAAS,EAAU,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;AAE9D;;;;;;;;;;;;;GAaG;AACH,MAAa,uBAAuB;IAApC;QACW,UAAK,GAAG,gBAAgB,CAAC;IAmCpC,CAAC;IAjCC,SAAS,CAAC,GAAqB;QAC7B,OAAO,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,KAAK,KAAK,CAAC;IAC5D,CAAC;IAEK,KAAK,CAAC,KAAqB,EAAE,GAAqB;;YACtD,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC;YACtD,IAAI,IAAI,KAAK,KAAK;gBAAE,OAAO,KAAK,CAAC;YAEjC,+DAA+D;YAC/D,MAAM,UAAU,GAAG,IAAI,GAAG,EAAU,CAAC;YACrC,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;gBACzB,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;oBAChC,IAAI,eAAe,CAAC,CAAC,CAAC;wBAAE,SAAS;oBACjC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;oBACtC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;gBACxC,CAAC;YACH,CAAC;YAED,MAAM,MAAM,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC;YACtC,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC7C,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;oBAAE,OAAO,IAAI,CAAC;gBACrC,IAAI,IAAI,KAAK,KAAK;oBAAE,OAAO,KAAK,CAAC;gBACjC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,wCAAwC;YACzF,CAAC,CAAC,CAAC;YAEH,MAAM,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;YAC1C,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;gBAChB,GAAG,CAAC,MAAM,CAAC,IAAI,CACb,oBAAoB,IAAI,aAAa,OAAO,IAAI,MAAM,uBAAuB,CAC9E,CAAC;YACJ,CAAC;YACD,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC;QACjD,CAAC;KAAA;CACF;AApCD,0DAoCC"}

package/dist/core/pipeline/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PipelineRunner"), exports);
+__exportStar(require("./GroundingTransform"), exports);
+__exportStar(require("./RelationFilterTransform"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/pipeline/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/pipeline/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,mDAAiC;AACjC,uDAAqC;AACrC,4DAA0C"}