@signetai/core 0.140.1

package/dist/ingest/chat-extractor.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Conversation-Aware Extraction for the ingestion engine.
+ *
+ * Specialized extraction logic for chat/conversation content.
+ * Different from document extraction:
+ * - Tracks speaker attribution
+ * - Extracts decisions, action items, preferences
+ * - Filters out greetings, casual banter, meta-conversation
+ * - Understands conversational context (agreements, disagreements)
+ *
+ * Uses an LlmProvider for extraction with a conversation-specific prompt.
+ */
+import type { LlmProvider } from "../types";
+import type { ChunkResult, ExtractionResult } from "./types";
+import type { ExtractionOptions } from "./extractor";
+/** @deprecated Use ExtractionOptions instead */
+export type ChatExtractorConfig = ExtractionOptions;
+export declare const DEFAULT_CHAT_EXTRACTOR_CONFIG: ExtractionOptions;
+/**
+ * Extract knowledge from a conversation chunk using an LLM.
+ *
+ * This is the conversation-specific equivalent of the document extractor.
+ * It uses a prompt tailored for conversational content with speaker attribution.
+ */
+export declare function extractFromConversation(chunk: ChunkResult, channelName: string | null, participants: string[], provider: LlmProvider, opts?: ExtractionOptions): Promise<ExtractionResult>;
+/**
+ * Extract knowledge from all conversation chunks.
+ */
+export declare function extractFromConversations(chunks: readonly ChunkResult[], channelName: string | null, participants: string[], provider: LlmProvider, onChunkDone?: (chunkIndex: number, itemCount: number) => void, opts?: ExtractionOptions): Promise<ExtractionResult[]>;
+/**
+ * Extract participants from a conversation chunk text.
+ * Looks for patterns like "[timestamp] Name: message"
+ */
+export declare function extractParticipants(chunkText: string): string[];
+//# sourceMappingURL=chat-extractor.d.ts.map

package/dist/ingest/chat-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-extractor.d.ts","sourceRoot":"","sources":["../../src/ingest/chat-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD,gDAAgD;AAChD,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;AAEpD,eAAO,MAAM,6BAA6B,EAAE,iBAE3C,CAAC;AA0IF;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAC5C,KAAK,EAAE,WAAW,EAClB,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,YAAY,EAAE,MAAM,EAAE,EACtB,QAAQ,EAAE,WAAW,EACrB,IAAI,GAAE,iBAAiD,GACrD,OAAO,CAAC,gBAAgB,CAAC,CA2B3B;AAED;;GAEG;AACH,wBAAsB,wBAAwB,CAC7C,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,YAAY,EAAE,MAAM,EAAE,EACtB,QAAQ,EAAE,WAAW,EACrB,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,EAC7D,IAAI,GAAE,iBAAiD,GACrD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAY7B;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAY/D"}

package/dist/ingest/chat-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared utilities for conversation-based parsers (Slack, Discord).
+ */
+/** Time gap threshold for splitting unthreaded messages (30 minutes) */
+export declare const TIME_GAP_MS: number;
+/**
+ * Batch a sorted array of items into groups separated by time gaps.
+ *
+ * Items within `TIME_GAP_MS` of each other end up in the same batch.
+ * The caller provides a `getTimestamp` function that returns a
+ * millisecond-epoch number for each item.
+ *
+ * @param items - Pre-sorted array of items (oldest first)
+ * @param getTimestamp - Extract ms-epoch timestamp from an item
+ * @returns Array of batches (each batch is a non-empty array of items)
+ */
+export declare function batchByTimeGap<T>(items: readonly T[], getTimestamp: (item: T) => number): T[][];
+//# sourceMappingURL=chat-utils.d.ts.map

package/dist/ingest/chat-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chat-utils.d.ts","sourceRoot":"","sources":["../../src/ingest/chat-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wEAAwE;AACxE,eAAO,MAAM,WAAW,QAAiB,CAAC;AAE1C;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,YAAY,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,CAAC,EAAE,EAAE,CAwB/F"}

package/dist/ingest/chunker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Structure-aware intelligent chunking for the ingestion engine.
+ *
+ * Unlike naive fixed-size chunking, this respects document structure:
+ * - Headers define chunk boundaries
+ * - Code blocks stay together
+ * - Lists stay together
+ * - Tables stay together
+ * - Overlap is applied at natural boundaries (sentences/paragraphs)
+ *
+ * Config: max ~2000 tokens (~8000 chars), min ~100 tokens, overlap ~200 tokens
+ */
+import type { ParsedDocument, ChunkResult } from "./types";
+export interface ChunkerConfig {
+    /** Maximum tokens per chunk (estimated as chars / 4) */
+    readonly maxTokens: number;
+    /** Minimum tokens per chunk — avoid tiny fragments */
+    readonly minTokens: number;
+    /** Overlap tokens between consecutive chunks */
+    readonly overlapTokens: number;
+}
+export declare const DEFAULT_CHUNKER_CONFIG: ChunkerConfig;
+/**
+ * Chunk a parsed document into overlapping, structure-aware chunks.
+ */
+export declare function chunkDocument(doc: ParsedDocument, config?: ChunkerConfig): ChunkResult[];
+//# sourceMappingURL=chunker.d.ts.map

package/dist/ingest/chunker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunker.d.ts","sourceRoot":"","sources":["../../src/ingest/chunker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAiB,WAAW,EAAE,MAAM,SAAS,CAAC;AAM1E,MAAM,WAAW,aAAa;IAC7B,wDAAwD;IACxD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,gDAAgD;IAChD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAED,eAAO,MAAM,sBAAsB,EAAE,aAIpC,CAAC;AAeF;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,GAAE,aAAsC,GAAG,WAAW,EAAE,CA+FhH"}

package/dist/ingest/code-parser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Code Repository Parser for the ingestion engine.
+ *
+ * Parses a git repository directory to extract:
+ * - README.md content (project overview, setup instructions)
+ * - package.json / pyproject.toml / Cargo.toml (dependencies, scripts)
+ * - Config files (.env.example, docker-compose.yml, etc.)
+ * - Git log (recent commit messages for architecture decisions, bug patterns)
+ * - Function/class extraction for major languages
+ * - Language detection from file extensions
+ *
+ * Produces a ParsedDocument with sections for architecture, dependencies,
+ * patterns, and recent development activity.
+ */
+import type { ParsedDocument } from "./types";
+/**
+ * Parse a git repository directory into a ParsedDocument.
+ *
+ * @param repoPath - Path to the repository root (must have .git/)
+ * @param options - Optional configuration
+ */
+export declare function parseCodeRepository(repoPath: string, options?: {
+    /** Include git log analysis (default: true) */
+    readonly includeGitLog?: boolean;
+    /** Max commits to parse (default: 100) */
+    readonly gitLogDepth?: number;
+    /** Only include specific file patterns */
+    readonly includePatterns?: string[];
+}): ParsedDocument;
+//# sourceMappingURL=code-parser.d.ts.map

package/dist/ingest/code-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-parser.d.ts","sourceRoot":"","sources":["../../src/ingest/code-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAC;AA0G7D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IACT,+CAA+C;IAC/C,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC,0CAA0C;IAC1C,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,0CAA0C;IAC1C,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CACpC,GACC,cAAc,CAmDhB"}

package/dist/ingest/discord-parser.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Discord Export Parser for the ingestion engine.
+ *
+ * Parses DiscordChatExporter JSON format, which can be:
+ * 1. A single JSON file with a channel's messages
+ * 2. A directory of JSON files (one per channel)
+ *
+ * DiscordChatExporter schema: { guild, channel, dateRange, messages[] }
+ * Each message: { id, type, timestamp, content, author, attachments, embeds, reference }
+ *
+ * Produces a ParsedDocument with sections grouped by conversation thread/time.
+ */
+import type { ParsedDocument } from "./types";
+/**
+ * Parse a Discord export (DiscordChatExporter format) into a ParsedDocument.
+ *
+ * @param path - Path to a JSON file or directory of JSON files
+ * @param options - Optional filtering
+ */
+export declare function parseDiscordExport(path: string, options?: {
+    /** Only include these channel names */
+    readonly channels?: string[];
+    /** Only include messages after this date */
+    readonly since?: string;
+    /** Only include messages before this date */
+    readonly until?: string;
+    /** Filter to specific speakers */
+    readonly speakers?: string[];
+}): ParsedDocument;
+//# sourceMappingURL=discord-parser.d.ts.map

package/dist/ingest/discord-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discord-parser.d.ts","sourceRoot":"","sources":["../../src/ingest/discord-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAC;AAsH7D;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE;IACT,uCAAuC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B,GACC,cAAc,CA8EhB"}

package/dist/ingest/entire-extractor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Entire.io Session Extraction for the ingestion engine.
+ *
+ * Specialized extraction logic for Entire.io AI coding session data.
+ * DIFFERENT from regular chat extraction — this focuses on extracting
+ * SKILL SIGNALS from developer-AI interaction patterns:
+ *
+ * - Skills demonstrated: technologies, tools, patterns used
+ * - Problem-solving approach: decomposition strategy, first moves
+ * - Decision paths: choices made, alternatives considered
+ * - Communication style with AI: prompt craftsmanship
+ * - Domain knowledge signals: what they know vs. ask about
+ * - Workflow patterns: build->test->commit cycles
+ * - Tool mastery: IDE features, CLI commands, framework expertise
+ *
+ * Uses an LlmProvider for extraction with a prompt specifically designed
+ * for developer skill assessment.
+ */
+import type { LlmProvider } from "../types";
+import type { ChunkResult, ExtractionResult } from "./types";
+import type { ExtractionOptions } from "./extractor";
+/** @deprecated Use ExtractionOptions instead */
+export type EntireExtractorConfig = ExtractionOptions;
+export declare const DEFAULT_ENTIRE_EXTRACTOR_CONFIG: ExtractionOptions;
+/**
+ * Extract skill signals from an Entire.io session chunk.
+ */
+export declare function extractFromEntireSession(chunk: ChunkResult, sessionMetadata: string | null, provider: LlmProvider, opts?: ExtractionOptions): Promise<ExtractionResult>;
+/**
+ * Extract skill signals from all Entire.io session chunks.
+ */
+export declare function extractFromEntireSessions(chunks: readonly ChunkResult[], sessionMetadata: string | null, provider: LlmProvider, onChunkDone?: (chunkIndex: number, itemCount: number) => void, opts?: ExtractionOptions): Promise<ExtractionResult[]>;
+//# sourceMappingURL=entire-extractor.d.ts.map

package/dist/ingest/entire-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entire-extractor.d.ts","sourceRoot":"","sources":["../../src/ingest/entire-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOrD,gDAAgD;AAChD,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC;AAEtD,eAAO,MAAM,+BAA+B,EAAE,iBAE7C,CAAC;AA8HF;;GAEG;AACH,wBAAsB,wBAAwB,CAC7C,KAAK,EAAE,WAAW,EAClB,eAAe,EAAE,MAAM,GAAG,IAAI,EAC9B,QAAQ,EAAE,WAAW,EACrB,IAAI,GAAE,iBAAmD,GACvD,OAAO,CAAC,gBAAgB,CAAC,CAsB3B;AAED;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,eAAe,EAAE,MAAM,GAAG,IAAI,EAC9B,QAAQ,EAAE,WAAW,EACrB,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,EAC7D,IAAI,GAAE,iBAAmD,GACvD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAY7B"}

package/dist/ingest/entire-parser.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Entire.io Session Parser for the ingestion engine.
+ *
+ * Parses Entire checkpoint data stored on the `entire/checkpoints/v1`
+ * shadow branch WITHOUT checking it out. Extracts:
+ * - Session transcripts (full prompt→response conversations)
+ * - Files touched per session
+ * - Checkpoint metadata (timestamps, commit links, strategy)
+ * - Agent info (Claude Code, Gemini CLI, etc.)
+ *
+ * Entire stores checkpoints in a sharded path structure on the branch:
+ *   <checkpoint-id[:2]>/<checkpoint-id[2:]>/
+ *   ├── metadata.json         (CheckpointSummary: aggregated stats, sessions list)
+ *   ├── 1/                    (session subdirectory)
+ *   │   ├── metadata.json     (CommittedMetadata: session-specific details)
+ *   │   ├── full.jsonl        (transcript in JSONL format)
+ *   │   ├── prompt.txt        (user prompts)
+ *   │   └── context.md        (generated context)
+ *   └── 2/ ...
+ *
+ * The JSONL transcript format has lines like:
+ *   {"uuid":"...","type":"user","message":{"content":"..."},"timestamp":"..."}
+ *   {"uuid":"...","type":"assistant","message":{"content":[{"type":"text","text":"..."}]},"timestamp":"..."}
+ */
+import type { ParsedDocument } from "./types";
+/**
+ * Check if a repository has Entire.io checkpoint data.
+ *
+ * @param repoPath - Path to the git repository root
+ * @returns true if the `entire/checkpoints/v1` branch exists
+ */
+export declare function hasEntireBranch(repoPath: string): boolean;
+/**
+ * Parse Entire.io sessions from a git repository.
+ *
+ * Reads the `entire/checkpoints/v1` branch without checking it out
+ * and extracts all session transcripts, metadata, and file change info.
+ *
+ * @param repoPath - Path to the repository root (must have .git/)
+ * @param options - Optional configuration
+ * @returns ParsedDocument with sections per session
+ */
+export declare function parseEntireRepo(repoPath: string, options?: {
+    /** Maximum number of sessions to parse (default: all) */
+    readonly maxSessions?: number;
+    /** Only include sessions after this date */
+    readonly since?: string;
+    /** Include raw transcript text in sections (default: true) */
+    readonly includeTranscripts?: boolean;
+}): ParsedDocument;
+//# sourceMappingURL=entire-parser.d.ts.map

package/dist/ingest/entire-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entire-parser.d.ts","sourceRoot":"","sources":["../../src/ingest/entire-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAC;AAmG7D;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAmBzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IACT,yDAAyD;IACzD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,QAAQ,CAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;CACtC,GACC,cAAc,CA+LhB"}

package/dist/ingest/extractor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * LLM-based knowledge extraction from document chunks.
+ *
+ * Uses an LlmProvider to extract structured knowledge:
+ * facts, decisions, preferences, procedures, relationships.
+ *
+ * The extraction prompt is the most critical part of the ingestion engine.
+ * It needs to produce genuinely useful, self-contained memories — not noise.
+ */
+import type { LlmProvider } from "../types";
+import type { ChunkResult, ExtractionResult } from "./types";
+export interface ExtractionOptions {
+    /** Minimum confidence to keep an extracted item */
+    readonly minConfidence: number;
+}
+/** @deprecated Use ExtractionOptions instead */
+export type ExtractorConfig = ExtractionOptions;
+export declare const DEFAULT_EXTRACTOR_CONFIG: ExtractionOptions;
+/**
+ * Extract knowledge from a single chunk using an LLM.
+ */
+export declare function extractFromChunk(chunk: ChunkResult, sourceTitle: string | null, provider: LlmProvider, opts?: ExtractionOptions): Promise<ExtractionResult>;
+/**
+ * Extract knowledge from all chunks in a document.
+ */
+export declare function extractFromChunks(chunks: readonly ChunkResult[], sourceTitle: string | null, provider: LlmProvider, onChunkDone?: (chunkIndex: number, itemCount: number) => void, opts?: ExtractionOptions): Promise<ExtractionResult[]>;
+//# sourceMappingURL=extractor.d.ts.map

package/dist/ingest/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../src/ingest/extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAO7D,MAAM,WAAW,iBAAiB;IACjC,mDAAmD;IACnD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAED,gDAAgD;AAChD,MAAM,MAAM,eAAe,GAAG,iBAAiB,CAAC;AAEhD,eAAO,MAAM,wBAAwB,EAAE,iBAEtC,CAAC;AAmGF;;GAEG;AACH,wBAAsB,gBAAgB,CACrC,KAAK,EAAE,WAAW,EAClB,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,QAAQ,EAAE,WAAW,EACrB,IAAI,GAAE,iBAA4C,GAChD,OAAO,CAAC,gBAAgB,CAAC,CAsB3B;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACtC,MAAM,EAAE,SAAS,WAAW,EAAE,EAC9B,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,QAAQ,EAAE,WAAW,EACrB,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,EAC7D,IAAI,GAAE,iBAA4C,GAChD,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAa7B"}

package/dist/ingest/git-utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared git binary resolution for parsers that shell out to git.
+ */
+/**
+ * Find the git binary path. Checks common locations, then falls back to `which`.
+ * Returns null if git is not found.
+ */
+export declare function findGit(): string | null;
+//# sourceMappingURL=git-utils.d.ts.map

package/dist/ingest/git-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-utils.d.ts","sourceRoot":"","sources":["../../src/ingest/git-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH;;;GAGG;AACH,wBAAgB,OAAO,IAAI,MAAM,GAAG,IAAI,CAyBvC"}

package/dist/ingest/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Document Ingestion Engine — "Pour your brain in"
+ *
+ * Main entry point: `ingestPath(path, options)` detects file type,
+ * parses documents, chunks intelligently, extracts knowledge via LLM,
+ * and stores as signed memories.
+ *
+ * Usage:
+ *   import { ingestPath } from "@signetai/core/ingest";
+ *   const result = await ingestPath("~/Documents/notes/", { db, verbose: true });
+ */
+import type { LlmProvider } from "../types";
+import type { IngestOptions, IngestResult, ProgressCallback } from "./types";
+export type { DatabaseLike, IngestOptions, IngestResult, FileIngestResult, ParsedDocument, ParsedSection, ChunkResult, ExtractionResult, ExtractedItem, ExtractedRelation, ProvenanceRecord, ProgressCallback, ProgressEvent, } from "./types";
+export { chunkDocument, DEFAULT_CHUNKER_CONFIG } from "./chunker";
+export type { ChunkerConfig } from "./chunker";
+export { extractFromChunk, extractFromChunks, DEFAULT_EXTRACTOR_CONFIG } from "./extractor";
+export type { ExtractionOptions, ExtractorConfig } from "./extractor";
+export { parseMarkdown, parseMarkdownContent, parseTxt, parseCode } from "./markdown-parser";
+export { parsePdf } from "./pdf-parser";
+export { parseSlackExport } from "./slack-parser";
+export { parseDiscordExport } from "./discord-parser";
+export { parseCodeRepository } from "./code-parser";
+export { parseEntireRepo, hasEntireBranch } from "./entire-parser";
+export { extractFromEntireSession, extractFromEntireSessions } from "./entire-extractor";
+export type { EntireExtractorConfig } from "./entire-extractor";
+export { extractFromConversation, extractFromConversations, extractParticipants } from "./chat-extractor";
+export type { ChatExtractorConfig } from "./chat-extractor";
+export { computeFileHash, buildProvenance } from "./provenance";
+export { parseExtractionResponse } from "./response-parser";
+export type { ParseOptions } from "./response-parser";
+export { findGit } from "./git-utils";
+export { batchByTimeGap, TIME_GAP_MS } from "./chat-utils";
+/**
+ * Ingest a file or directory of documents.
+ *
+ * This is the "pour your brain in" function. Point it at a path
+ * and it will:
+ * 1. Detect all supported files
+ * 2. Parse each file into sections
+ * 3. Chunk sections intelligently
+ * 4. Extract knowledge using an LLM
+ * 5. Store as memories with provenance tracking
+ *
+ * @param inputPath - File or directory to ingest
+ * @param options - Configuration options
+ * @param provider - LLM provider for extraction (required unless skipExtraction)
+ * @param onProgress - Optional progress callback
+ * @returns Ingestion results summary
+ */
+export declare function ingestPath(inputPath: string, options?: IngestOptions, provider?: LlmProvider, onProgress?: ProgressCallback): Promise<IngestResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/ingest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ingest/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAEX,aAAa,EACb,YAAY,EAKZ,gBAAgB,EAChB,MAAM,SAAS,CAAC;AAoBjB,YAAY,EACX,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAClE,YAAY,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAC5F,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC7F,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AACzF,YAAY,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC1G,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,YAAY,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AA2T3D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,UAAU,CAC/B,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,aAAkB,EAC3B,QAAQ,CAAC,EAAE,WAAW,EACtB,UAAU,CAAC,EAAE,gBAAgB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAiGvB"}

package/dist/ingest/markdown-parser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Markdown / TXT parser for the ingestion engine.
+ *
+ * Parses markdown into sections, respecting heading hierarchy.
+ * Handles code blocks, tables, lists, and blockquotes as distinct content types.
+ */
+import type { ParsedDocument } from "./types";
+/**
+ * Parse a markdown or plain text file into structured sections.
+ */
+export declare function parseMarkdown(filePath: string): ParsedDocument;
+/**
+ * Parse markdown content string directly (for testing / reuse).
+ */
+export declare function parseMarkdownContent(content: string, title?: string | null): ParsedDocument;
+/**
+ * Parse a plain text file (no markdown structure).
+ * Splits on blank lines as paragraph boundaries.
+ */
+export declare function parseTxt(filePath: string): ParsedDocument;
+/**
+ * Parse a code file — treat the whole file as one code section
+ * with the filename as the heading.
+ */
+export declare function parseCode(filePath: string): ParsedDocument;
+//# sourceMappingURL=markdown-parser.d.ts.map

package/dist/ingest/markdown-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-parser.d.ts","sourceRoot":"","sources":["../../src/ingest/markdown-parser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAC;AAM7D;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAG9D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,GAAG,IAAW,GAAG,cAAc,CA4JjG;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAoBzD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,CAoD1D"}

package/dist/ingest/pdf-parser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * PDF parser for the ingestion engine.
+ *
+ * Uses pdf-parse (v2) to extract text, then applies heuristic section detection
+ * (large text on its own line → heading, page breaks → section boundaries).
+ */
+import type { ParsedDocument } from "./types";
+/**
+ * Parse a PDF file into structured sections.
+ *
+ * Uses pdf-parse v2 API (PDFParse class with { data } constructor).
+ */
+export declare function parsePdf(filePath: string): Promise<ParsedDocument>;
+//# sourceMappingURL=pdf-parser.d.ts.map

package/dist/ingest/pdf-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdf-parser.d.ts","sourceRoot":"","sources":["../../src/ingest/pdf-parser.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAC;AAyB7D;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CA+ExE"}

package/dist/ingest/provenance.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Provenance tracking for ingested documents.
+ *
+ * Records where each piece of knowledge came from:
+ * source file, section, page, line range, and ingestion timestamp.
+ */
+import type { ChunkResult, DatabaseLike, ProvenanceRecord } from "./types";
+/**
+ * Compute a SHA-256 hash of a file for deduplication.
+ */
+export declare function computeFileHash(filePath: string): string;
+/**
+ * Check if a file has already been ingested (by hash).
+ * Returns the existing job ID if found, null otherwise.
+ */
+export declare function checkAlreadyIngested(db: DatabaseLike, fileHash: string): string | null;
+/**
+ * Build a provenance record for a chunk.
+ */
+export declare function buildProvenance(chunk: ChunkResult, filePath: string, sourceType: string, fileHash: string): ProvenanceRecord;
+/**
+ * Get file metadata for tracking.
+ */
+export declare function getFileMetadata(filePath: string): {
+    size: number;
+    modified: string;
+};
+export interface IngestionJobRow {
+    id: string;
+    source_path: string;
+    source_type: string;
+    file_hash: string;
+    status: string;
+    chunks_total: number;
+    chunks_processed: number;
+    memories_created: number;
+    started_at: string;
+    completed_at: string | null;
+    error: string | null;
+}
+/**
+ * Create an ingestion job record in the database.
+ */
+export declare function createIngestionJob(db: DatabaseLike, jobId: string, sourcePath: string, sourceType: string, fileHash: string): void;
+/**
+ * Update an ingestion job's progress.
+ */
+export declare function updateIngestionJob(db: DatabaseLike, jobId: string, updates: {
+    status?: string;
+    chunksTotal?: number;
+    chunksProcessed?: number;
+    memoriesCreated?: number;
+    error?: string;
+}): void;
+//# sourceMappingURL=provenance.d.ts.map

package/dist/ingest/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../src/ingest/provenance.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAM3E;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQxD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAStF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACd,gBAAgB,CAYlB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CACjB,CAUA;AAMD,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CACjC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACd,IAAI,CAUN;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CACjC,EAAE,EAAE,YAAY,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,GACC,IAAI,CAsCN"}

package/dist/ingest/response-parser.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Shared LLM response parser for the extraction pipeline.
+ *
+ * Parses raw LLM text responses into structured extraction results.
+ * Handles markdown fences, <think> blocks, JSON repair, type normalization,
+ * and confidence filtering.
+ *
+ * Previously named ollama-client.ts — renamed to reflect actual responsibility
+ * now that LLM transport is handled by the LlmProvider interface.
+ */
+import type { ExtractedItem, ExtractedRelation } from "./types";
+export interface ParseOptions {
+    /** Minimum confidence to keep an extracted item */
+    readonly minConfidence: number;
+    /** Set of valid type strings */
+    readonly validTypes: ReadonlySet<string>;
+    /** Map of alternative type names → canonical type names */
+    readonly typeMap: Readonly<Record<string, string>>;
+    /** Default type when none matches */
+    readonly defaultType: string;
+    /** Minimum content length to keep an item (0 = no minimum) */
+    readonly minContentLength?: number;
+}
+/**
+ * Parse an LLM response string into structured items and relations.
+ *
+ * Handles:
+ * - Markdown code fences around JSON
+ * - <think> reasoning blocks (some models emit these)
+ * - Trailing comma repair
+ * - Flexible key names ("items" / "facts", "relations" / "entities")
+ * - Type normalization via validTypes + typeMap
+ * - Confidence clamping and filtering
+ */
+export declare function parseExtractionResponse(raw: string, options: ParseOptions): {
+    items: ExtractedItem[];
+    relations: ExtractedRelation[];
+    warnings: string[];
+};
+//# sourceMappingURL=response-parser.d.ts.map

package/dist/ingest/response-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-parser.d.ts","sourceRoot":"","sources":["../../src/ingest/response-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAMhE,MAAM,WAAW,YAAY;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,gCAAgC;IAChC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACzC,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,qCAAqC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACnC;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACtC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,YAAY,GACnB;IACF,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;CACnB,CAiHA"}

package/dist/ingest/slack-parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Slack Export Parser for the ingestion engine.
+ *
+ * Parses the Slack JSON export format:
+ * - Root directory contains channels.json, users.json
+ * - Each channel has a subdirectory with dated JSON files (YYYY-MM-DD.json)
+ * - Each JSON file is an array of message objects
+ *
+ * Produces a ParsedDocument with messages grouped by conversation thread.
+ * Filters out bot messages, join/leave events, and noise.
+ */
+import type { ParsedDocument } from "./types";
+/**
+ * Parse a Slack export directory into a ParsedDocument.
+ *
+ * The directory should contain:
+ * - users.json (optional but recommended)
+ * - channels.json (optional)
+ * - One subdirectory per channel, each containing YYYY-MM-DD.json files
+ *
+ * @param dirPath - Path to the Slack export root directory
+ * @param options - Optional filtering
+ */
+export declare function parseSlackExport(dirPath: string, options?: {
+    /** Only include these channels */
+    readonly channels?: string[];
+    /** Only include messages after this date */
+    readonly since?: string;
+    /** Only include messages before this date */
+    readonly until?: string;
+    /** Filter to specific speakers */
+    readonly speakers?: string[];
+}): ParsedDocument;
+//# sourceMappingURL=slack-parser.d.ts.map

package/dist/ingest/slack-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-parser.d.ts","sourceRoot":"","sources":["../../src/ingest/slack-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAiB,MAAM,SAAS,CAAC;AA8E7D;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IACT,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,4CAA4C;IAC5C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,6CAA6C;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,kCAAkC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B,GACC,cAAc,CA8DhB"}