@dreamtree-org/graphify 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,301 @@
+import Graph from 'graphology';
+import { z } from 'zod';
+
+type Confidence = 'EXTRACTED' | 'INFERRED' | 'AMBIGUOUS';
+type Relation = 'calls' | 'imports' | 'imports_from' | 'inherits' | 'implements' | 'mixes_in' | 'embeds' | 'references' | 'contains' | 'method' | 're_exports';
+interface GraphNode {
+    id: string;
+    label: string;
+    sourceFile: string;
+    sourceLocation: string;
+}
+interface GraphEdge {
+    source: string;
+    target: string;
+    relation: Relation;
+    confidence: Confidence;
+}
+/** Per-file extractor output. Validate against this shape before buildGraph() consumes it. */
+interface ExtractionResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+type FileCategory = 'code' | 'document' | 'paper' | 'image' | 'video';
+interface FileManifest {
+    scanRoot: string;
+    files: Record<FileCategory, string[]>;
+    totalFiles: number;
+    totalWords: number;
+    skippedSensitive: string[];
+}
+interface Analysis {
+    godNodes: string[];
+    surprises: string[];
+    openQuestions: string[];
+}
+interface ExportOptions {
+    outDir: string;
+    html?: boolean;
+    svg?: boolean;
+    graphml?: boolean;
+    neo4j?: boolean;
+    obsidian?: boolean;
+    obsidianDir?: string;
+}
+
+/**
+ * Walk `root` and categorize files into code/document/paper/image/video
+ * buckets. Does not follow symlinks (security.ts §5 — symlink traversal).
+ * Sensitive-looking files (.env, credentials, key material) are recorded in
+ * `skippedSensitive` and excluded from every other bucket/count.
+ */
+declare function collectFiles(root: string): FileManifest;
+
+type Extractor = (path: string) => Promise<ExtractionResult>;
+/** File extension -> extractor module. Register new languages here. */
+declare const EXTRACTOR_REGISTRY: Record<string, Extractor>;
+/**
+ * Dispatch a single file to its language extractor. Returns an empty
+ * extraction (not a thrown error) for unregistered extensions so detect's
+ * file list and extract's coverage can diverge without crashing a run.
+ */
+declare function extract(filePath: string): Promise<ExtractionResult>;
+
+/**
+ * Merge per-file extraction results into one graphology graph.
+ *
+ * Every extraction is validated against the ExtractionResult schema before
+ * anything is added to the graph — a single malformed extraction throws
+ * (via validateExtraction()/ExtractionValidationError) before any node from
+ * *any* extraction is merged, so a bad extractor can never silently
+ * corrupt a graph that also contains good data.
+ *
+ * Nodes and edges are sorted before being added so the resulting graph (and
+ * the graph.json ultimately exported from it) is deterministic regardless
+ * of the order files were extracted in. Duplicate edges — same
+ * source/target/relation, e.g. two different call sites resolving to the
+ * same callee — are merged into a single edge, keeping the strongest
+ * confidence seen (EXTRACTED > INFERRED > AMBIGUOUS) rather than being
+ * counted as parallel edges (the schema has no call-count/weight field, so
+ * "A calls B" is either true or it isn't). Multiple distinct relations
+ * between the same pair (e.g. a file both `imports` and `imports_from` the
+ * same module) are kept as separate edges.
+ */
+declare function buildGraph(extractions: ExtractionResult[]): Graph;
+
+type ClusterAlgorithm = 'louvain' | 'leiden';
+interface ClusterOptions {
+    /**
+     * `louvain` (default, v1 behavior, unchanged) or `leiden` (v2: better
+     * community quality / guaranteed well-connectedness, via
+     * `@aflsolutions/graphology-communities-leiden` — see master prompt's
+     * v2 upgrade ideas, "Real Leiden clustering"). Both run deterministically
+     * against a sorted working copy with the same fixed-seed PRNG.
+     */
+    algorithm?: ClusterAlgorithm;
+    /**
+     * Leiden-only: hard cap on outer iterations, for very large graphs where
+     * full convergence is expensive and the last iterations buy little
+     * additional modularity. Ignored for `algorithm: 'louvain'`.
+     */
+    maxIterations?: number;
+}
+/**
+ * Community detection — Louvain by default (v1, unchanged), or Leiden
+ * (v2, `{ algorithm: 'leiden' }`) for better-quality, guaranteed
+ * well-connected communities on the same graph. Deterministic: runs
+ * against a sorted working copy with a fixed RNG seed, then copies the
+ * resulting `community` assignment back onto the original graph by node id
+ * (so `cluster()` still mutates and returns the graph instance it was
+ * given). Labels each community after its highest-degree ("hub") member;
+ * no LLM required for a usable baseline. Also stamps a `communityHash`
+ * (sha256 of the community's sorted member ids) so `--cluster-only` can
+ * tell which communities actually changed vs. merely being relabeled with
+ * a different arbitrary index next run.
+ */
+declare function cluster(graph: Graph, options?: ClusterOptions): Graph;
+
+/**
+ * Surface god-nodes (excessive fan-in/out), structural surprises (self
+ * references, AMBIGUOUS edges), and open questions (isolated nodes,
+ * disconnected components) for a human to review in GRAPH_REPORT.md.
+ */
+declare function analyze(graph: Graph): Analysis;
+
+/**
+ * Render the plain-language GRAPH_REPORT.md content: a short summary,
+ * community breakdown, god nodes, structural surprises, and open
+ * questions — everything a human (or an agent) needs to sanity-check a
+ * freshly built graph before trusting it.
+ */
+declare function renderReport(graph: Graph, analysis: Analysis, now?: Date): string;
+
+/**
+ * Write graph.json (graphology's node-link serialization, GraphRAG-ready)
+ * and, per options, graph.html (vis-network, bundled inline — no CDN, works
+ * fully offline) and GRAPH_REPORT.md. Every label/title embedded in
+ * graph.html is passed through security.sanitizeLabel() + escapeHtml()
+ * first (XSS control, see SECURITY.md).
+ *
+ * Obsidian vault / .graphml / Neo4j cypher export are NOT implemented in
+ * v1 — if requested, exportGraph logs a clear warning and skips them
+ * rather than silently doing nothing or faking output.
+ */
+declare function exportGraph(graph: Graph, options: ExportOptions, report?: string): Promise<void>;
+
+interface PipelineOptions {
+    /** Where to write graph.json/graph.html/GRAPH_REPORT.md. Defaults to `<root>/graphify-out`. */
+    outDir?: string;
+    html?: boolean;
+    svg?: boolean;
+    graphml?: boolean;
+    neo4j?: boolean;
+    obsidian?: boolean;
+    /** `louvain` (default, v1) or `leiden` (v2 — better community quality, see cluster.ts). */
+    algorithm?: ClusterAlgorithm;
+    /** Leiden-only: cap on outer iterations for very large graphs. */
+    maxIterations?: number;
+    /** Called with a short progress message after each stage (e.g. for CLI stderr output). */
+    onProgress?: (message: string) => void;
+}
+interface PipelineResult {
+    manifest: FileManifest;
+    graph: Graph;
+    analysis: Analysis;
+    report: string;
+}
+/**
+ * The full `detect -> extract -> build -> cluster -> analyze -> report ->
+ * export` pipeline as a single library call — the CLI's default command is
+ * a thin wrapper over this. Every extension registered in
+ * EXTRACTOR_REGISTRY (see extract.ts) is run; files with no registered
+ * extractor are skipped (not an error — see extract()'s doc comment).
+ */
+declare function runPipeline(root: string, options?: PipelineOptions): Promise<PipelineResult>;
+
+/**
+ * Load a previously-exported graph.json back into a graphology Graph.
+ * Always goes through security.validateGraphPath() (path-traversal guard —
+ * see SECURITY.md) so a caller-supplied `outDir`/CLI arg can never make
+ * this read outside the graphify-out/ directory it resolves to.
+ */
+declare function loadGraph(outDir?: string): Promise<Graph>;
+
+interface NodeMatch {
+    id: string;
+    label: string;
+    score: number;
+}
+/** Score every node by how many query tokens appear in its label or id. */
+declare function scoreNodes(graph: Graph, query: string): NodeMatch[];
+/**
+ * Best-effort single-node resolution: the highest-scoring lexical match,
+ * or null if nothing in the graph matches at all. Deliberately does *not*
+ * fall back to "the most connected node" — path/explain name a specific
+ * node by intent, and silently substituting an unrelated one would be
+ * more misleading than clearly saying "no match".
+ */
+declare function resolveNode(graph: Graph, query: string): NodeMatch | null;
+interface VisitedNode {
+    id: string;
+    label: string;
+    sourceFile: string;
+    sourceLocation: string;
+    depth: number;
+}
+interface TraversalEdge {
+    source: string;
+    target: string;
+    relation: string;
+    confidence: string;
+}
+interface QueryResult {
+    seeds: NodeMatch[];
+    visited: VisitedNode[];
+    edges: TraversalEdge[];
+}
+interface QueryOptions {
+    dfs?: boolean;
+    /** Approximate cap on how many nodes to include (a stand-in for a true token budget — see docs). */
+    budget?: number;
+    maxDepth?: number;
+    maxSeeds?: number;
+}
+/**
+ * BFS (default, broad context) or DFS (--dfs, trace a specific path)
+ * traversal from the nodes whose label best matches `question`'s
+ * keywords. This is lexical retrieval, not natural-language
+ * understanding — it surfaces the neighborhood of the graph an agent (or
+ * a human) should look at to answer the question, it does not itself
+ * compose an answer.
+ */
+declare function queryGraph(graph: Graph, question: string, options?: QueryOptions): QueryResult;
+interface PathResult {
+    from: NodeMatch;
+    to: NodeMatch;
+    found: boolean;
+    path: string[];
+    edges: TraversalEdge[];
+}
+/** Shortest path between the nodes that best match `fromQuery` and `toQuery` (undirected BFS — connectivity, not call direction). */
+declare function shortestPath(graph: Graph, fromQuery: string, toQuery: string): PathResult | null;
+interface ExplainResult {
+    id: string;
+    label: string;
+    sourceFile: string;
+    sourceLocation: string;
+    communityLabel?: string;
+    outgoing: TraversalEdge[];
+    incoming: TraversalEdge[];
+}
+/** Plain-language-ready explanation of the node that best matches `query`. */
+declare function explainNode(graph: Graph, query: string): ExplainResult | null;
+
+declare const ExtractionResultSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        sourceFile: z.ZodString;
+        sourceLocation: z.ZodString;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        relation: z.ZodEnum<{
+            calls: "calls";
+            imports: "imports";
+            imports_from: "imports_from";
+            inherits: "inherits";
+            implements: "implements";
+            mixes_in: "mixes_in";
+            embeds: "embeds";
+            references: "references";
+            contains: "contains";
+            method: "method";
+            re_exports: "re_exports";
+        }>;
+        confidence: z.ZodEnum<{
+            EXTRACTED: "EXTRACTED";
+            INFERRED: "INFERRED";
+            AMBIGUOUS: "AMBIGUOUS";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+interface ExtractionValidationIssue {
+    path: Array<string | number>;
+    message: string;
+}
+/** Thrown by validateExtraction() on schema mismatch. Carries the raw zod issues. */
+declare class ExtractionValidationError extends Error {
+    readonly issues: ExtractionValidationIssue[];
+    constructor(message: string, issues: ExtractionValidationIssue[]);
+}
+/**
+ * Validate an unknown value (typically an extractor's return value) against
+ * the ExtractionResult schema. Throws ExtractionValidationError with a clear,
+ * human-readable message on mismatch instead of letting malformed data reach
+ * buildGraph().
+ */
+declare function validateExtraction(value: unknown, context?: string): ExtractionResult;
+
+export { type Analysis, type ClusterAlgorithm, type ClusterOptions, type Confidence, EXTRACTOR_REGISTRY, type ExplainResult, type ExportOptions, type ExtractionResult, ExtractionResultSchema, ExtractionValidationError, type ExtractionValidationIssue, type FileCategory, type FileManifest, type GraphEdge, type GraphNode, type NodeMatch, type PathResult, type PipelineOptions, type PipelineResult, type QueryOptions, type QueryResult, type Relation, type TraversalEdge, type VisitedNode, analyze, buildGraph, cluster, collectFiles, explainNode, exportGraph, extract, loadGraph, queryGraph, renderReport, resolveNode, runPipeline, scoreNodes, shortestPath, validateExtraction };

package/dist/index.d.ts

@@ -0,0 +1,301 @@
+import Graph from 'graphology';
+import { z } from 'zod';
+
+type Confidence = 'EXTRACTED' | 'INFERRED' | 'AMBIGUOUS';
+type Relation = 'calls' | 'imports' | 'imports_from' | 'inherits' | 'implements' | 'mixes_in' | 'embeds' | 'references' | 'contains' | 'method' | 're_exports';
+interface GraphNode {
+    id: string;
+    label: string;
+    sourceFile: string;
+    sourceLocation: string;
+}
+interface GraphEdge {
+    source: string;
+    target: string;
+    relation: Relation;
+    confidence: Confidence;
+}
+/** Per-file extractor output. Validate against this shape before buildGraph() consumes it. */
+interface ExtractionResult {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+type FileCategory = 'code' | 'document' | 'paper' | 'image' | 'video';
+interface FileManifest {
+    scanRoot: string;
+    files: Record<FileCategory, string[]>;
+    totalFiles: number;
+    totalWords: number;
+    skippedSensitive: string[];
+}
+interface Analysis {
+    godNodes: string[];
+    surprises: string[];
+    openQuestions: string[];
+}
+interface ExportOptions {
+    outDir: string;
+    html?: boolean;
+    svg?: boolean;
+    graphml?: boolean;
+    neo4j?: boolean;
+    obsidian?: boolean;
+    obsidianDir?: string;
+}
+
+/**
+ * Walk `root` and categorize files into code/document/paper/image/video
+ * buckets. Does not follow symlinks (security.ts §5 — symlink traversal).
+ * Sensitive-looking files (.env, credentials, key material) are recorded in
+ * `skippedSensitive` and excluded from every other bucket/count.
+ */
+declare function collectFiles(root: string): FileManifest;
+
+type Extractor = (path: string) => Promise<ExtractionResult>;
+/** File extension -> extractor module. Register new languages here. */
+declare const EXTRACTOR_REGISTRY: Record<string, Extractor>;
+/**
+ * Dispatch a single file to its language extractor. Returns an empty
+ * extraction (not a thrown error) for unregistered extensions so detect's
+ * file list and extract's coverage can diverge without crashing a run.
+ */
+declare function extract(filePath: string): Promise<ExtractionResult>;
+
+/**
+ * Merge per-file extraction results into one graphology graph.
+ *
+ * Every extraction is validated against the ExtractionResult schema before
+ * anything is added to the graph — a single malformed extraction throws
+ * (via validateExtraction()/ExtractionValidationError) before any node from
+ * *any* extraction is merged, so a bad extractor can never silently
+ * corrupt a graph that also contains good data.
+ *
+ * Nodes and edges are sorted before being added so the resulting graph (and
+ * the graph.json ultimately exported from it) is deterministic regardless
+ * of the order files were extracted in. Duplicate edges — same
+ * source/target/relation, e.g. two different call sites resolving to the
+ * same callee — are merged into a single edge, keeping the strongest
+ * confidence seen (EXTRACTED > INFERRED > AMBIGUOUS) rather than being
+ * counted as parallel edges (the schema has no call-count/weight field, so
+ * "A calls B" is either true or it isn't). Multiple distinct relations
+ * between the same pair (e.g. a file both `imports` and `imports_from` the
+ * same module) are kept as separate edges.
+ */
+declare function buildGraph(extractions: ExtractionResult[]): Graph;
+
+type ClusterAlgorithm = 'louvain' | 'leiden';
+interface ClusterOptions {
+    /**
+     * `louvain` (default, v1 behavior, unchanged) or `leiden` (v2: better
+     * community quality / guaranteed well-connectedness, via
+     * `@aflsolutions/graphology-communities-leiden` — see master prompt's
+     * v2 upgrade ideas, "Real Leiden clustering"). Both run deterministically
+     * against a sorted working copy with the same fixed-seed PRNG.
+     */
+    algorithm?: ClusterAlgorithm;
+    /**
+     * Leiden-only: hard cap on outer iterations, for very large graphs where
+     * full convergence is expensive and the last iterations buy little
+     * additional modularity. Ignored for `algorithm: 'louvain'`.
+     */
+    maxIterations?: number;
+}
+/**
+ * Community detection — Louvain by default (v1, unchanged), or Leiden
+ * (v2, `{ algorithm: 'leiden' }`) for better-quality, guaranteed
+ * well-connected communities on the same graph. Deterministic: runs
+ * against a sorted working copy with a fixed RNG seed, then copies the
+ * resulting `community` assignment back onto the original graph by node id
+ * (so `cluster()` still mutates and returns the graph instance it was
+ * given). Labels each community after its highest-degree ("hub") member;
+ * no LLM required for a usable baseline. Also stamps a `communityHash`
+ * (sha256 of the community's sorted member ids) so `--cluster-only` can
+ * tell which communities actually changed vs. merely being relabeled with
+ * a different arbitrary index next run.
+ */
+declare function cluster(graph: Graph, options?: ClusterOptions): Graph;
+
+/**
+ * Surface god-nodes (excessive fan-in/out), structural surprises (self
+ * references, AMBIGUOUS edges), and open questions (isolated nodes,
+ * disconnected components) for a human to review in GRAPH_REPORT.md.
+ */
+declare function analyze(graph: Graph): Analysis;
+
+/**
+ * Render the plain-language GRAPH_REPORT.md content: a short summary,
+ * community breakdown, god nodes, structural surprises, and open
+ * questions — everything a human (or an agent) needs to sanity-check a
+ * freshly built graph before trusting it.
+ */
+declare function renderReport(graph: Graph, analysis: Analysis, now?: Date): string;
+
+/**
+ * Write graph.json (graphology's node-link serialization, GraphRAG-ready)
+ * and, per options, graph.html (vis-network, bundled inline — no CDN, works
+ * fully offline) and GRAPH_REPORT.md. Every label/title embedded in
+ * graph.html is passed through security.sanitizeLabel() + escapeHtml()
+ * first (XSS control, see SECURITY.md).
+ *
+ * Obsidian vault / .graphml / Neo4j cypher export are NOT implemented in
+ * v1 — if requested, exportGraph logs a clear warning and skips them
+ * rather than silently doing nothing or faking output.
+ */
+declare function exportGraph(graph: Graph, options: ExportOptions, report?: string): Promise<void>;
+
+interface PipelineOptions {
+    /** Where to write graph.json/graph.html/GRAPH_REPORT.md. Defaults to `<root>/graphify-out`. */
+    outDir?: string;
+    html?: boolean;
+    svg?: boolean;
+    graphml?: boolean;
+    neo4j?: boolean;
+    obsidian?: boolean;
+    /** `louvain` (default, v1) or `leiden` (v2 — better community quality, see cluster.ts). */
+    algorithm?: ClusterAlgorithm;
+    /** Leiden-only: cap on outer iterations for very large graphs. */
+    maxIterations?: number;
+    /** Called with a short progress message after each stage (e.g. for CLI stderr output). */
+    onProgress?: (message: string) => void;
+}
+interface PipelineResult {
+    manifest: FileManifest;
+    graph: Graph;
+    analysis: Analysis;
+    report: string;
+}
+/**
+ * The full `detect -> extract -> build -> cluster -> analyze -> report ->
+ * export` pipeline as a single library call — the CLI's default command is
+ * a thin wrapper over this. Every extension registered in
+ * EXTRACTOR_REGISTRY (see extract.ts) is run; files with no registered
+ * extractor are skipped (not an error — see extract()'s doc comment).
+ */
+declare function runPipeline(root: string, options?: PipelineOptions): Promise<PipelineResult>;
+
+/**
+ * Load a previously-exported graph.json back into a graphology Graph.
+ * Always goes through security.validateGraphPath() (path-traversal guard —
+ * see SECURITY.md) so a caller-supplied `outDir`/CLI arg can never make
+ * this read outside the graphify-out/ directory it resolves to.
+ */
+declare function loadGraph(outDir?: string): Promise<Graph>;
+
+interface NodeMatch {
+    id: string;
+    label: string;
+    score: number;
+}
+/** Score every node by how many query tokens appear in its label or id. */
+declare function scoreNodes(graph: Graph, query: string): NodeMatch[];
+/**
+ * Best-effort single-node resolution: the highest-scoring lexical match,
+ * or null if nothing in the graph matches at all. Deliberately does *not*
+ * fall back to "the most connected node" — path/explain name a specific
+ * node by intent, and silently substituting an unrelated one would be
+ * more misleading than clearly saying "no match".
+ */
+declare function resolveNode(graph: Graph, query: string): NodeMatch | null;
+interface VisitedNode {
+    id: string;
+    label: string;
+    sourceFile: string;
+    sourceLocation: string;
+    depth: number;
+}
+interface TraversalEdge {
+    source: string;
+    target: string;
+    relation: string;
+    confidence: string;
+}
+interface QueryResult {
+    seeds: NodeMatch[];
+    visited: VisitedNode[];
+    edges: TraversalEdge[];
+}
+interface QueryOptions {
+    dfs?: boolean;
+    /** Approximate cap on how many nodes to include (a stand-in for a true token budget — see docs). */
+    budget?: number;
+    maxDepth?: number;
+    maxSeeds?: number;
+}
+/**
+ * BFS (default, broad context) or DFS (--dfs, trace a specific path)
+ * traversal from the nodes whose label best matches `question`'s
+ * keywords. This is lexical retrieval, not natural-language
+ * understanding — it surfaces the neighborhood of the graph an agent (or
+ * a human) should look at to answer the question, it does not itself
+ * compose an answer.
+ */
+declare function queryGraph(graph: Graph, question: string, options?: QueryOptions): QueryResult;
+interface PathResult {
+    from: NodeMatch;
+    to: NodeMatch;
+    found: boolean;
+    path: string[];
+    edges: TraversalEdge[];
+}
+/** Shortest path between the nodes that best match `fromQuery` and `toQuery` (undirected BFS — connectivity, not call direction). */
+declare function shortestPath(graph: Graph, fromQuery: string, toQuery: string): PathResult | null;
+interface ExplainResult {
+    id: string;
+    label: string;
+    sourceFile: string;
+    sourceLocation: string;
+    communityLabel?: string;
+    outgoing: TraversalEdge[];
+    incoming: TraversalEdge[];
+}
+/** Plain-language-ready explanation of the node that best matches `query`. */
+declare function explainNode(graph: Graph, query: string): ExplainResult | null;
+
+declare const ExtractionResultSchema: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        sourceFile: z.ZodString;
+        sourceLocation: z.ZodString;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        relation: z.ZodEnum<{
+            calls: "calls";
+            imports: "imports";
+            imports_from: "imports_from";
+            inherits: "inherits";
+            implements: "implements";
+            mixes_in: "mixes_in";
+            embeds: "embeds";
+            references: "references";
+            contains: "contains";
+            method: "method";
+            re_exports: "re_exports";
+        }>;
+        confidence: z.ZodEnum<{
+            EXTRACTED: "EXTRACTED";
+            INFERRED: "INFERRED";
+            AMBIGUOUS: "AMBIGUOUS";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+interface ExtractionValidationIssue {
+    path: Array<string | number>;
+    message: string;
+}
+/** Thrown by validateExtraction() on schema mismatch. Carries the raw zod issues. */
+declare class ExtractionValidationError extends Error {
+    readonly issues: ExtractionValidationIssue[];
+    constructor(message: string, issues: ExtractionValidationIssue[]);
+}
+/**
+ * Validate an unknown value (typically an extractor's return value) against
+ * the ExtractionResult schema. Throws ExtractionValidationError with a clear,
+ * human-readable message on mismatch instead of letting malformed data reach
+ * buildGraph().
+ */
+declare function validateExtraction(value: unknown, context?: string): ExtractionResult;
+
+export { type Analysis, type ClusterAlgorithm, type ClusterOptions, type Confidence, EXTRACTOR_REGISTRY, type ExplainResult, type ExportOptions, type ExtractionResult, ExtractionResultSchema, ExtractionValidationError, type ExtractionValidationIssue, type FileCategory, type FileManifest, type GraphEdge, type GraphNode, type NodeMatch, type PathResult, type PipelineOptions, type PipelineResult, type QueryOptions, type QueryResult, type Relation, type TraversalEdge, type VisitedNode, analyze, buildGraph, cluster, collectFiles, explainNode, exportGraph, extract, loadGraph, queryGraph, renderReport, resolveNode, runPipeline, scoreNodes, shortestPath, validateExtraction };

package/dist/index.js

@@ -0,0 +1,43 @@
+import {
+  EXTRACTOR_REGISTRY,
+  ExtractionResultSchema,
+  ExtractionValidationError,
+  analyze,
+  buildGraph,
+  cluster,
+  collectFiles,
+  exportGraph,
+  extract,
+  renderReport,
+  runPipeline,
+  validateExtraction
+} from "./chunk-DG5FECXV.js";
+import {
+  explainNode,
+  loadGraph,
+  queryGraph,
+  resolveNode,
+  scoreNodes,
+  shortestPath
+} from "./chunk-5ANIDX3G.js";
+export {
+  EXTRACTOR_REGISTRY,
+  ExtractionResultSchema,
+  ExtractionValidationError,
+  analyze,
+  buildGraph,
+  cluster,
+  collectFiles,
+  explainNode,
+  exportGraph,
+  extract,
+  loadGraph,
+  queryGraph,
+  renderReport,
+  resolveNode,
+  runPipeline,
+  scoreNodes,
+  shortestPath,
+  validateExtraction
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}