@crowdlisten/harness 1.0.0

package/dist/context/cli.js

@@ -0,0 +1,108 @@
+/**
+ * CLI subcommands for context extraction.
+ *
+ * npx @crowdlisten/harness context          # Launch web UI
+ * npx @crowdlisten/harness context <file>   # CLI-only processing
+ * npx @crowdlisten/harness setup            # Configure LLM provider (handled in index.ts)
+ */
+import { runPipeline } from "./pipeline.js";
+import { loadConfig, saveConfig } from "./store.js";
+import { startContextServer } from "./server.js";
+import * as readline from "readline";
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Interactive setup: configure LLM provider and API key.
+ */
+export async function runSetupContext() {
+    console.error("\n🔧 CrowdListen Context — LLM Provider Setup\n");
+    const existing = loadConfig();
+    if (existing) {
+        console.error(`Current config: ${existing.provider} (${existing.model || "default model"})`);
+    }
+    const providerInput = await prompt("Provider (openai / anthropic) [openai]: ");
+    const provider = (providerInput || "openai");
+    const apiKey = await prompt(`${provider === "openai" ? "OpenAI" : "Anthropic"} API key: `);
+    if (!apiKey) {
+        console.error("❌ API key required.");
+        process.exit(1);
+    }
+    const modelInput = await prompt("Model (press Enter for default): ");
+    const config = {
+        provider,
+        apiKey,
+        ...(modelInput ? { model: modelInput } : {}),
+    };
+    saveConfig(config);
+    console.error(`\n✅ Saved to ~/.crowdlisten/config.json`);
+    console.error(`   Provider: ${config.provider}`);
+    console.error(`   Model: ${config.model || "default"}\n`);
+}
+/**
+ * Process a file via CLI (no web UI).
+ */
+export async function runContextCLI(filePath) {
+    const config = loadConfig();
+    if (!config) {
+        console.error("No LLM provider configured. Run: npx @crowdlisten/harness setup");
+        process.exit(1);
+    }
+    console.error(`\n📄 Processing: ${filePath}`);
+    console.error(`   Provider: ${config.provider} (${config.model || "default"})\n`);
+    try {
+        const result = await runPipeline({
+            filePath,
+            source: filePath,
+            onProgress: ({ current, total, blocksFound }) => {
+                console.error(`   Chunk ${current}/${total} — ${blocksFound} blocks found`);
+            },
+        });
+        console.error(`\n🛡️  PII Redaction:`);
+        if (result.totalRedactions > 0) {
+            for (const [type, count] of Object.entries(result.redactionStats)) {
+                console.error(`   ${type}: ${count} redacted`);
+            }
+        }
+        else {
+            console.error("   No PII detected");
+        }
+        console.error(`\n📦 Extracted ${result.blocks.length} context blocks:\n`);
+        for (const block of result.blocks) {
+            console.error(`   [${block.type}] ${block.title}`);
+            console.error(`   ${block.content}\n`);
+        }
+        if (result.skills.length > 0) {
+            console.error(`🎯 Recommended Skills:\n`);
+            for (const skill of result.skills) {
+                console.error(`   ${skill.name} (${Math.round(skill.score * 100)}% match)`);
+                console.error(`   ${skill.description}\n`);
+            }
+        }
+        // Output JSON to stdout for piping
+        process.stdout.write(JSON.stringify(result, null, 2));
+    }
+    catch (err) {
+        console.error(`\n❌ ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+}
+/**
+ * Launch the web UI server.
+ */
+export async function runContextWeb() {
+    const config = loadConfig();
+    if (!config) {
+        console.error("⚠️  No LLM provider configured. You can configure it in the web UI or run: npx @crowdlisten/harness setup\n");
+    }
+    await startContextServer();
+}

package/dist/context/extractor.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Extract context blocks from text using the configured LLM provider.
+ */
+import type { LLMProvider, ContextBlock } from "./types.js";
+/**
+ * Extract context blocks from a text chunk.
+ * @param provider - LLM provider instance
+ * @param text - Text to extract from (will be truncated to 80k chars)
+ * @param source - Source label for the text
+ * @param isChat - Whether this is chat history (uses 4-type prompt) or general text (2-type)
+ */
+export declare function extractBlocks(provider: LLMProvider, text: string, source: string, isChat?: boolean): Promise<ContextBlock[]>;

package/dist/context/extractor.js

@@ -0,0 +1,43 @@
+/**
+ * Extract context blocks from text using the configured LLM provider.
+ */
+import { CHAT_EXTRACT_SYSTEM_PROMPT, EXTRACT_SYSTEM_PROMPT } from "./prompts.js";
+const MAX_INPUT_CHARS = 80_000;
+const MAX_RETRIES = 2;
+/**
+ * Extract context blocks from a text chunk.
+ * @param provider - LLM provider instance
+ * @param text - Text to extract from (will be truncated to 80k chars)
+ * @param source - Source label for the text
+ * @param isChat - Whether this is chat history (uses 4-type prompt) or general text (2-type)
+ */
+export async function extractBlocks(provider, text, source, isChat = true) {
+    const trimmed = text.slice(0, MAX_INPUT_CHARS);
+    const systemPrompt = isChat
+        ? CHAT_EXTRACT_SYSTEM_PROMPT
+        : EXTRACT_SYSTEM_PROMPT;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const response = await provider.complete([
+                { role: "system", content: systemPrompt },
+                { role: "user", content: `Source: "${source}"\n\n${trimmed}` },
+            ], { temperature: 0.3, jsonMode: true });
+            const parsed = JSON.parse(response);
+            const blocks = (parsed.blocks || []).map((b) => ({
+                type: b.type,
+                title: b.title,
+                content: b.content,
+                source,
+            }));
+            return blocks;
+        }
+        catch (err) {
+            if (attempt === MAX_RETRIES) {
+                throw new Error(`Context extraction failed after ${MAX_RETRIES + 1} attempts: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            // Brief delay before retry
+            await new Promise((r) => setTimeout(r, 1000 * (attempt + 1)));
+        }
+    }
+    return []; // unreachable but satisfies TS
+}

package/dist/context/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Context extraction pipeline — barrel export.
+ */
+export { redactPII } from "./redactor.js";
+export { parseFile, parseTextContent, parseZipBuffer, chunkText } from "./parser.js";
+export { extractBlocks } from "./extractor.js";
+export { matchSkills, discoverSkills, searchSkills, getSkillCategories, getFullCatalog } from "./matcher.js";
+export { createProvider } from "./providers.js";
+export { runPipeline } from "./pipeline.js";
+export type { PipelineOpts } from "./pipeline.js";
+export * from "./store.js";
+export * from "./types.js";

package/dist/context/index.js

@@ -0,0 +1,11 @@
+/**
+ * Context extraction pipeline — barrel export.
+ */
+export { redactPII } from "./redactor.js";
+export { parseFile, parseTextContent, parseZipBuffer, chunkText } from "./parser.js";
+export { extractBlocks } from "./extractor.js";
+export { matchSkills, discoverSkills, searchSkills, getSkillCategories, getFullCatalog } from "./matcher.js";
+export { createProvider } from "./providers.js";
+export { runPipeline } from "./pipeline.js";
+export * from "./store.js";
+export * from "./types.js";

package/dist/context/matcher.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Skill matching: cosine similarity on keyword overlap + TF-IDF-like scoring
+ * against both native and community skill catalogs.
+ */
+import type { ContextBlock, SkillMatch, ExtendedSkillCatalogEntry, ExtendedSkillMatch, SkillTier, SkillCategory } from "./types.js";
+/**
+ * Load both catalogs combined. Exported for install lookups.
+ */
+export declare function getFullCatalog(): ExtendedSkillCatalogEntry[];
+/**
+ * Match context blocks against the skill catalog (backward-compatible).
+ * Returns top matching skills sorted by score.
+ */
+export declare function matchSkills(blocks: ContextBlock[], topN?: number): Promise<SkillMatch[]>;
+/**
+ * Enhanced skill discovery with tier boost and category affinity.
+ * Scores against BOTH native and community catalogs.
+ */
+export declare function discoverSkills(blocks: ContextBlock[], options?: {
+    category?: SkillCategory;
+    tier?: SkillTier;
+    limit?: number;
+}): Promise<ExtendedSkillMatch[]>;
+/**
+ * Full-text search across both skill catalogs.
+ */
+export declare function searchSkills(query: string, options?: {
+    tier?: SkillTier;
+    category?: SkillCategory;
+}): ExtendedSkillMatch[];
+/**
+ * Get category summary with counts.
+ */
+export declare function getSkillCategories(): Array<{
+    category: SkillCategory;
+    count: number;
+    nativeCount: number;
+    communityCount: number;
+}>;

package/dist/context/matcher.js

@@ -0,0 +1,246 @@
+/**
+ * Skill matching: cosine similarity on keyword overlap + TF-IDF-like scoring
+ * against both native and community skill catalogs.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let nativeCatalogCache = null;
+let communityCatalogCache = null;
+function loadJsonFile(candidates) {
+    for (const p of candidates) {
+        try {
+            const raw = fs.readFileSync(p, "utf-8");
+            return JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Load native CrowdListen skills and wrap them as ExtendedSkillCatalogEntry.
+ */
+function loadNativeCatalog() {
+    if (nativeCatalogCache)
+        return nativeCatalogCache;
+    const raw = loadJsonFile([
+        path.join(__dirname, "..", "..", "skills", "catalog.json"),
+        path.join(__dirname, "..", "..", "dist", "skills", "catalog.json"),
+    ]);
+    if (!raw) {
+        nativeCatalogCache = [];
+        return [];
+    }
+    nativeCatalogCache = raw.map((entry) => ({
+        ...entry,
+        tier: "crowdlisten",
+        category: "research", // CrowdListen skills are research/audience intel
+        installMethod: "copy",
+        installTarget: `crowdlisten:${entry.id}`,
+        source: "crowdlisten/native",
+    }));
+    return nativeCatalogCache;
+}
+/**
+ * Load community skill catalog.
+ */
+function loadCommunityCatalog() {
+    if (communityCatalogCache)
+        return communityCatalogCache;
+    const raw = loadJsonFile([
+        path.join(__dirname, "..", "..", "skills", "community-catalog.json"),
+        path.join(__dirname, "..", "..", "dist", "skills", "community-catalog.json"),
+    ]);
+    communityCatalogCache = raw || [];
+    return communityCatalogCache;
+}
+/**
+ * Load both catalogs combined. Exported for install lookups.
+ */
+export function getFullCatalog() {
+    return loadFullCatalog();
+}
+function loadFullCatalog() {
+    return [...loadNativeCatalog(), ...loadCommunityCatalog()];
+}
+/**
+ * Extract keywords from context blocks for matching.
+ */
+function extractBlockKeywords(blocks) {
+    const words = [];
+    for (const block of blocks) {
+        const text = `${block.title} ${block.content}`.toLowerCase();
+        const tokens = text
+            .replace(/[^a-z0-9\s-]/g, " ")
+            .split(/\s+/)
+            .filter((w) => w.length > 3);
+        words.push(...tokens);
+    }
+    return words;
+}
+/**
+ * Detect dominant category from block keywords.
+ */
+const CATEGORY_KEYWORD_MAP = {
+    development: ["code", "debug", "refactor", "typescript", "javascript", "react", "component", "testing", "git", "api", "function", "class"],
+    data: ["data", "database", "sql", "analytics", "machine", "learning", "model", "statistics", "visualization", "pipeline"],
+    content: ["content", "writing", "blog", "seo", "copy", "editorial", "article", "social", "media"],
+    research: ["research", "analysis", "market", "competitive", "audience", "insights", "trends"],
+    automation: ["deploy", "docker", "kubernetes", "cicd", "pipeline", "terraform", "cloud", "monitoring", "automation"],
+    design: ["design", "ui", "ux", "accessibility", "css", "layout", "responsive", "figma"],
+    business: ["strategy", "pricing", "marketing", "sales", "growth", "funnel", "acquisition", "revenue"],
+    productivity: ["workflow", "documentation", "onboarding", "planning", "template", "organization"],
+};
+function categoryAffinity(blockKeywords, category) {
+    const categoryKws = CATEGORY_KEYWORD_MAP[category] || [];
+    const blockSet = new Set(blockKeywords);
+    let matches = 0;
+    for (const kw of categoryKws) {
+        for (const bk of blockSet) {
+            if (bk.includes(kw) || kw.includes(bk)) {
+                matches++;
+                break;
+            }
+        }
+    }
+    return categoryKws.length > 0 ? matches / categoryKws.length : 0;
+}
+/**
+ * Calculate keyword overlap score between block keywords and skill keywords.
+ * Returns a score between 0 and 1.
+ */
+function keywordOverlapScore(blockKeywords, skillKeywords) {
+    const blockSet = new Set(blockKeywords);
+    const matched = [];
+    for (const kw of skillKeywords) {
+        // Check exact match
+        if (blockSet.has(kw)) {
+            matched.push(kw);
+            continue;
+        }
+        // Check partial match (block keyword contains skill keyword or vice versa)
+        for (const bk of blockSet) {
+            if (bk.includes(kw) || kw.includes(bk)) {
+                matched.push(kw);
+                break;
+            }
+        }
+    }
+    if (skillKeywords.length === 0)
+        return { score: 0, matchedKeywords: [] };
+    // Score: fraction of skill keywords that matched, weighted by frequency
+    const score = matched.length / skillKeywords.length;
+    return { score, matchedKeywords: [...new Set(matched)] };
+}
+/**
+ * Match context blocks against the skill catalog (backward-compatible).
+ * Returns top matching skills sorted by score.
+ */
+export async function matchSkills(blocks, topN = 5) {
+    const results = await discoverSkills(blocks, { limit: topN });
+    // Return as SkillMatch for backward compatibility
+    return results.map(({ tier, category, installMethod, installTarget, ...rest }) => rest);
+}
+/**
+ * Enhanced skill discovery with tier boost and category affinity.
+ * Scores against BOTH native and community catalogs.
+ */
+export async function discoverSkills(blocks, options = {}) {
+    let catalog = loadFullCatalog();
+    if (catalog.length === 0 || blocks.length === 0)
+        return [];
+    // Apply filters
+    if (options.tier)
+        catalog = catalog.filter((s) => s.tier === options.tier);
+    if (options.category)
+        catalog = catalog.filter((s) => s.category === options.category);
+    const blockKeywords = extractBlockKeywords(blocks);
+    const results = [];
+    for (const skill of catalog) {
+        const { score: baseScore, matchedKeywords } = keywordOverlapScore(blockKeywords, skill.keywords);
+        // Tier boost: native skills get a slight advantage
+        const tierBoost = skill.tier === "crowdlisten" ? 0.10 : 0;
+        // Category affinity: bonus when context keywords cluster matches skill category
+        const catBoost = categoryAffinity(blockKeywords, skill.category) * 0.05;
+        const finalScore = Math.min(baseScore + tierBoost + catBoost, 1);
+        if (finalScore > 0.05) {
+            results.push({
+                skillId: skill.id,
+                name: skill.name,
+                description: skill.description,
+                score: Math.round(finalScore * 100) / 100,
+                matchedKeywords,
+                tier: skill.tier,
+                category: skill.category,
+                installMethod: skill.installMethod,
+                installTarget: skill.installTarget,
+            });
+        }
+    }
+    // Sort by score descending
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, options.limit || 10);
+}
+/**
+ * Full-text search across both skill catalogs.
+ */
+export function searchSkills(query, options = {}) {
+    let catalog = loadFullCatalog();
+    if (options.tier)
+        catalog = catalog.filter((s) => s.tier === options.tier);
+    if (options.category)
+        catalog = catalog.filter((s) => s.category === options.category);
+    const q = query.toLowerCase();
+    const results = [];
+    for (const skill of catalog) {
+        const haystack = `${skill.name} ${skill.description} ${skill.keywords.join(" ")}`.toLowerCase();
+        if (!haystack.includes(q))
+            continue;
+        // Simple relevance: how early the query appears + name match bonus
+        const nameMatch = skill.name.toLowerCase().includes(q) ? 0.3 : 0;
+        const descMatch = skill.description.toLowerCase().includes(q) ? 0.15 : 0;
+        const kwMatch = skill.keywords.some((kw) => kw.includes(q)) ? 0.1 : 0;
+        const score = Math.min(nameMatch + descMatch + kwMatch + 0.2, 1);
+        results.push({
+            skillId: skill.id,
+            name: skill.name,
+            description: skill.description,
+            score: Math.round(score * 100) / 100,
+            matchedKeywords: skill.keywords.filter((kw) => kw.includes(q)),
+            tier: skill.tier,
+            category: skill.category,
+            installMethod: skill.installMethod,
+            installTarget: skill.installTarget,
+        });
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results;
+}
+/**
+ * Get category summary with counts.
+ */
+export function getSkillCategories() {
+    const catalog = loadFullCatalog();
+    const cats = {};
+    for (const skill of catalog) {
+        if (!cats[skill.category])
+            cats[skill.category] = { total: 0, native: 0, community: 0 };
+        cats[skill.category].total++;
+        if (skill.tier === "crowdlisten")
+            cats[skill.category].native++;
+        else
+            cats[skill.category].community++;
+    }
+    return Object.entries(cats)
+        .map(([category, { total, native, community }]) => ({
+        category: category,
+        count: total,
+        nativeCount: native,
+        communityCount: community,
+    }))
+        .sort((a, b) => b.count - a.count);
+}

package/dist/context/parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Parse chat exports (.json, .zip, .txt, .md, .pdf) and chunk text.
+ * Ported from crowdlisten_deployed/frontend/src/services/chatHistoryService.js
+ * Decoupled from browser File API — works with Node.js buffers/strings.
+ */
+/**
+ * Parse a single file from a buffer or string. Handles .json, .txt, .md.
+ * For .zip, use parseZipBuffer(). For .pdf, use parsePdfBuffer().
+ */
+export declare function parseTextContent(content: string, filename: string): string;
+/**
+ * Parse a ZIP buffer containing chat exports.
+ * Requires jszip to be installed.
+ */
+export declare function parseZipBuffer(buffer: Buffer): Promise<string>;
+/**
+ * Parse a PDF buffer into text.
+ * Requires pdf-parse to be installed.
+ */
+export declare function parsePdfBuffer(buffer: Buffer): Promise<string>;
+/**
+ * Parse a file from disk by path.
+ */
+export declare function parseFile(filePath: string): Promise<string>;
+/**
+ * Split text into chunks of ~maxChars at paragraph boundaries.
+ */
+export declare function chunkText(text: string, maxChars?: number): string[];

package/dist/context/parser.js

@@ -0,0 +1,157 @@
+/**
+ * Parse chat exports (.json, .zip, .txt, .md, .pdf) and chunk text.
+ * Ported from crowdlisten_deployed/frontend/src/services/chatHistoryService.js
+ * Decoupled from browser File API — works with Node.js buffers/strings.
+ */
+const BATCH_CHAR_LIMIT = 12_000;
+// ─── Parsers ──────────────────────────────────────────────────────────────────
+/**
+ * Parse ChatGPT export JSON (conversations[].mapping -> user+assistant messages)
+ */
+function parseChatGPTExport(json) {
+    const texts = [];
+    const conversations = Array.isArray(json) ? json : [json];
+    for (const convo of conversations) {
+        if (!convo?.mapping)
+            continue;
+        for (const node of Object.values(convo.mapping)) {
+            const msg = node?.message;
+            if (!msg?.content?.parts?.length)
+                continue;
+            if (msg.author?.role === "user" || msg.author?.role === "assistant") {
+                texts.push(msg.content.parts.join("\n"));
+            }
+        }
+    }
+    return texts.join("\n\n---\n\n");
+}
+/**
+ * Parse Claude export JSON (conversations[].chat_messages -> text content)
+ */
+function parseClaudeExport(json) {
+    const texts = [];
+    const conversations = Array.isArray(json) ? json : [json];
+    for (const convo of conversations) {
+        const c = convo;
+        const messages = c.chat_messages || c.messages || [];
+        for (const msg of messages) {
+            const text = msg.text ||
+                (typeof msg.content === "string"
+                    ? msg.content
+                    : Array.isArray(msg.content)
+                        ? msg.content
+                            .filter((c) => c.type === "text")
+                            .map((c) => c.text)
+                            .join("\n")
+                        : null);
+            if (text)
+                texts.push(text);
+        }
+    }
+    return texts.join("\n\n---\n\n");
+}
+/**
+ * Auto-detect format and parse JSON content.
+ */
+function parseJSON(json) {
+    const arr = Array.isArray(json) ? json : [json];
+    const sample = (arr[0] || {});
+    if (sample.mapping)
+        return parseChatGPTExport(json);
+    if (sample.chat_messages || (sample.messages && sample.uuid))
+        return parseClaudeExport(json);
+    return JSON.stringify(json, null, 2);
+}
+// ─── File Parsing ────────────────────────────────────────────────────────────
+/**
+ * Parse a single file from a buffer or string. Handles .json, .txt, .md.
+ * For .zip, use parseZipBuffer(). For .pdf, use parsePdfBuffer().
+ */
+export function parseTextContent(content, filename) {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    if (ext === "json") {
+        try {
+            return parseJSON(JSON.parse(content));
+        }
+        catch {
+            return content;
+        }
+    }
+    return content;
+}
+/**
+ * Parse a ZIP buffer containing chat exports.
+ * Requires jszip to be installed.
+ */
+export async function parseZipBuffer(buffer) {
+    const JSZip = (await import("jszip")).default;
+    const zip = await JSZip.loadAsync(buffer);
+    const texts = [];
+    for (const [name, entry] of Object.entries(zip.files)) {
+        if (entry.dir)
+            continue;
+        const content = await entry.async("string");
+        if (name.endsWith(".json")) {
+            try {
+                texts.push(parseJSON(JSON.parse(content)));
+            }
+            catch {
+                texts.push(content);
+            }
+        }
+        else {
+            texts.push(content);
+        }
+    }
+    return texts.join("\n\n---\n\n");
+}
+/**
+ * Parse a PDF buffer into text.
+ * Requires pdf-parse to be installed.
+ */
+export async function parsePdfBuffer(buffer) {
+    const pdfParse = (await import("pdf-parse")).default;
+    const data = await pdfParse(buffer);
+    return data.text;
+}
+/**
+ * Parse a file from disk by path.
+ */
+export async function parseFile(filePath) {
+    const fs = await import("fs/promises");
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (ext === "zip") {
+        const buffer = await fs.readFile(filePath);
+        return parseZipBuffer(buffer);
+    }
+    if (ext === "pdf") {
+        const buffer = await fs.readFile(filePath);
+        return parsePdfBuffer(buffer);
+    }
+    const content = await fs.readFile(filePath, "utf-8");
+    return parseTextContent(content, filePath);
+}
+// ─── Chunking ────────────────────────────────────────────────────────────────
+/**
+ * Split text into chunks of ~maxChars at paragraph boundaries.
+ */
+export function chunkText(text, maxChars = BATCH_CHAR_LIMIT) {
+    if (text.length <= maxChars)
+        return [text];
+    const chunks = [];
+    let start = 0;
+    while (start < text.length) {
+        let end = start + maxChars;
+        if (end >= text.length) {
+            chunks.push(text.slice(start));
+            break;
+        }
+        const breakPoint = text.lastIndexOf("\n\n", end);
+        if (breakPoint > start + maxChars * 0.5) {
+            end = breakPoint;
+        }
+        chunks.push(text.slice(start, end));
+        start = end;
+    }
+    return chunks;
+}

package/dist/context/pipeline.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Orchestrator: parse -> redact -> chunk -> extract -> match -> store
+ */
+import type { ContextConfig, PipelineResult } from "./types.js";
+export interface PipelineOpts {
+    /** Raw text input (from paste or direct input) */
+    text?: string;
+    /** File path to process */
+    filePath?: string;
+    /** Source label for tracking */
+    source?: string;
+    /** Override config (otherwise loads from ~/.crowdlisten/config.json) */
+    config?: ContextConfig;
+    /** Whether input is chat history (uses 4-type prompt) */
+    isChat?: boolean;
+    /** Progress callback */
+    onProgress?: (progress: {
+        current: number;
+        total: number;
+        blocksFound: number;
+    }) => void;
+}
+/**
+ * Run the full context extraction pipeline.
+ */
+export declare function runPipeline(opts: PipelineOpts): Promise<PipelineResult>;