ricord 1.0.0

package/dist/init.js

@@ -0,0 +1,839 @@
+#!/usr/bin/env node
+/**
+ * ricord init — Full conversation-to-knowledge compiler.
+ *
+ * Implements the claude-memory-compiler pipeline via Ricord's API:
+ *   conversation → turns → facts → memories → KB/wiki articles
+ *
+ * Pipeline:
+ *   1. Scan ~/.claude/projects/ for ALL JSONL conversations
+ *   2. Optionally scan ~/.claude/ memory files (CLAUDE.md, memory/)
+ *   3. For each conversation:
+ *      a. Parse ALL turns (user + assistant)
+ *      b. Generate a stable session_id from file content hash
+ *      c. Chunk into segments preserving turn boundaries
+ *      d. For each segment → POST /v1/memories, which auto-triggers:
+ *           · Atomic fact decomposition
+ *           · Knowledge graph entity extraction + edge storage
+ *           · KB page enrichment (auto-generated wiki rollups)
+ *           · Search key expansion
+ *           · Conflict detection + resolution
+ *      f. Write structured daily log entry (claude-memory-compiler format)
+ *   4. Process memory files (preferences, feedback, project context)
+ *   5. Run compilation pass: refresh all KB pages, run lint
+ *   6. Generate summary report
+ *
+ * Capabilities:
+ *   - Daily logs (structured source layer)
+ *   - Compiled wiki articles (KB pages with 500-2000 word bodies)
+ *   - Connection entities (cross-cutting insights via knowledge graph)
+ *   - Compounding Q&A (facts accumulate for better retrieval)
+ *   - Contradiction detection (conflict resolution in wiki pipeline)
+ *   - Fact extraction (rule-based)
+ *
+ * Usage:
+ *   npx ricord-mcp init                        # process all projects
+ *   npx ricord-mcp init --project ricord-ai    # one project only
+ *   npx ricord-mcp init --dry-run              # show what would be processed
+ *   npx ricord-mcp init --limit 10             # first 10 conversations
+ *   npx ricord-mcp init --since 2026-04-01     # only after this date
+ *   npx ricord-mcp init --include-memory       # also process ~/.claude memory files
+ *   npx ricord-mcp init --memory-only          # sync memory files only, skip conversations (fast, for session-start)
+ *   npx ricord-mcp init --compile              # run KB compilation pass after ingest
+ *   npx ricord-mcp init --full                 # include-memory + compile (recommended)
+ */
+import { readFileSync, existsSync, readdirSync, statSync, writeFileSync, mkdirSync, appendFileSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+// ── Constants ───────────────────────────────────────────────────────
+const CLAUDE_DIR = join(homedir(), ".claude");
+const PROJECTS_DIR = join(CLAUDE_DIR, "projects");
+const CREDENTIALS_FILE = join(homedir(), ".ricord", "credentials.json");
+const STATE_DIR = join(homedir(), ".ricord");
+const INIT_STATE_FILE = join(STATE_DIR, "init-state.json");
+// Pipeline tuning
+const MAX_SEGMENT_CHARS = 6000; // ~1500 tokens per segment for rich extraction
+const MAX_TURNS_PER_SEGMENT = 20; // keep segments coherent
+const BATCH_DELAY_MS = 200; // rate-limit friendly
+const DEFAULT_PROJECT = "general";
+// Daily log directory (local audit trail, like claude-memory-compiler's daily/)
+const DAILY_DIR = join(import.meta.dirname ? join(import.meta.dirname, "..", "..") : process.cwd(), "daily");
+// ── CLI args ────────────────────────────────────────────────────────
+const args = process.argv.slice(2);
+function getArg(name) {
+    const idx = args.indexOf(`--${name}`);
+    return idx !== -1 ? args[idx + 1] : undefined;
+}
+const DRY_RUN = args.includes("--dry-run");
+const LIMIT = parseInt(getArg("limit") || "0", 10);
+const SINCE = getArg("since") || "";
+const PROJECT_FILTER = getArg("project") || "";
+const MEMORY_ONLY = args.includes("--memory-only");
+const INCLUDE_MEMORY = MEMORY_ONLY || args.includes("--include-memory") || args.includes("--full");
+const RUN_COMPILE = !MEMORY_ONLY && (args.includes("--compile") || args.includes("--full"));
+function loadCredentials() {
+    try {
+        if (existsSync(CREDENTIALS_FILE)) {
+            return JSON.parse(readFileSync(CREDENTIALS_FILE, "utf8"));
+        }
+    }
+    catch { }
+    return null;
+}
+function loadInitState() {
+    try {
+        if (existsSync(INIT_STATE_FILE)) {
+            return JSON.parse(readFileSync(INIT_STATE_FILE, "utf8"));
+        }
+    }
+    catch { }
+    return {
+        processed: {},
+        memory_files_processed: {},
+        total_episodes: 0,
+        total_items: 0,
+        total_turns: 0,
+        last_run: "",
+        runs: 0,
+    };
+}
+function saveInitState(state) {
+    if (!existsSync(STATE_DIR))
+        mkdirSync(STATE_DIR, { recursive: true });
+    writeFileSync(INIT_STATE_FILE, JSON.stringify(state, null, 2), "utf8");
+}
+function fileContentHash(content) {
+    return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+// ── Credential scrubbing ────────────────────────────────────────────
+function scrubCredentials(text) {
+    return text
+        .replace(/sk-[a-zA-Z0-9_\-]{8,}/g, "[REDACTED]")
+        .replace(/sk_[a-zA-Z0-9_\-]{8,}/g, "[REDACTED]")
+        .replace(/pk-[a-zA-Z0-9_\-]{8,}/g, "[REDACTED]")
+        .replace(/key-[a-zA-Z0-9_\-]{8,}/g, "[REDACTED]")
+        .replace(/AIza[a-zA-Z0-9_\-]{20,}/g, "[REDACTED]")
+        .replace(/ghp_[a-zA-Z0-9]{10,}/g, "[REDACTED]")
+        .replace(/gho_[a-zA-Z0-9]{10,}/g, "[REDACTED]")
+        .replace(/xox[bp]-[a-zA-Z0-9\-]+/g, "[REDACTED]")
+        .replace(/glpat-[a-zA-Z0-9_\-]{10,}/g, "[REDACTED]")
+        .replace(/AKIA[A-Z0-9]{12,}/g, "[REDACTED]")
+        .replace(/((?:api[_-]?key|token|secret|password|credential|bearer|authorization)\s*[:=]\s*["']?)([a-zA-Z0-9_\-./+=]{10,})/gi, "$1[REDACTED]")
+        .replace(/(export\s+\w*(?:KEY|TOKEN|SECRET|PASSWORD)\w*\s*=\s*["']?)([^\s"']{10,})/gi, "$1[REDACTED]")
+        .replace(/((?:postgres(?:ql)?|mysql|redis|mongodb):\/\/[^:]+:)[^@]+(@)/gi, "$1[REDACTED]$2")
+        .replace(/(Bearer\s+)[a-zA-Z0-9_\-./+=]{10,}/gi, "$1[REDACTED]")
+        // SEC-06: Removed overly-broad base64 regex (/\b[A-Za-z0-9+/]{40,200}={0,3}\b/g)
+        // which was erroneously redacting git SHAs, file hashes, and other legitimate content.
+        .replace(/"(api_key|apiKey|secret_key|secretKey|access_token|accessToken|private_key|privateKey)"\s*:\s*"[^"]{10,}"/gi, '"$1": "[REDACTED]"');
+}
+// ── Project name extraction ─────────────────────────────────────────
+function dirToProjectId(dirName) {
+    let name = dirName
+        .replace(/^-Users-[^-]+-Documents-/i, "")
+        .replace(/^-Users-[^-]+-/i, "")
+        .replace(/^-+/, "");
+    const parts = name.split("-");
+    if (parts[0]?.toLowerCase() === "hexaclaw" && parts.length > 1) {
+        name = parts.slice(1).join("-");
+    }
+    if (name.includes("paperclip"))
+        return "paperclip";
+    return name.toLowerCase() || DEFAULT_PROJECT;
+}
+/**
+ * Parse ALL turns from a JSONL transcript file.
+ * Unlike the old init.ts which only took the last 30, this reads everything
+ * so the full conversation context is available for extraction.
+ */
+function parseAllTurns(filePath) {
+    const turns = [];
+    let index = 0;
+    try {
+        const content = readFileSync(filePath, "utf8");
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                const msg = entry.message || entry;
+                const role = msg.role || "";
+                let text = msg.content || "";
+                if (!["user", "assistant"].includes(role))
+                    continue;
+                if (Array.isArray(text)) {
+                    text = text
+                        .filter((b) => typeof b === "string" || (b.type === "text" && b.text))
+                        .map((b) => (typeof b === "string" ? b : b.text))
+                        .join("\n");
+                }
+                if (typeof text === "string" && text.trim()) {
+                    turns.push({ role: role, content: text.trim(), index: index++ });
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch { /* file read error */ }
+    return turns;
+}
+/**
+ * Chunk a conversation into segments that preserve turn boundaries.
+ * Each segment is small enough for effective extraction but large enough
+ * for coherent understanding.
+ *
+ * This is analogous to claude-memory-compiler's approach of processing
+ * the last 30 turns per session — but we process ALL turns in chunks.
+ */
+function segmentConversation(turns) {
+    const segments = [];
+    let currentTurns = [];
+    let currentChars = 0;
+    for (const turn of turns) {
+        const turnText = `**${turn.role === "user" ? "User" : "Assistant"}:** ${turn.content}`;
+        // Start a new segment if this one is full
+        if (currentTurns.length >= MAX_TURNS_PER_SEGMENT ||
+            (currentChars + turnText.length > MAX_SEGMENT_CHARS && currentTurns.length > 0)) {
+            segments.push(buildSegment(currentTurns));
+            currentTurns = [];
+            currentChars = 0;
+        }
+        currentTurns.push(turn);
+        currentChars += turnText.length;
+    }
+    // Flush remaining
+    if (currentTurns.length > 0) {
+        segments.push(buildSegment(currentTurns));
+    }
+    return segments;
+}
+function buildSegment(turns) {
+    const context = turns
+        .map(t => `**${t.role === "user" ? "User" : "Assistant"}:** ${t.content}`)
+        .join("\n\n");
+    const userTurnCount = turns.filter(t => t.role === "user").length;
+    const first = turns[0]?.index ?? 0;
+    const last = turns[turns.length - 1]?.index ?? 0;
+    return {
+        turns,
+        context: scrubCredentials(context),
+        turnRange: `${first + 1}-${last + 1}`,
+        userTurnCount,
+    };
+}
+function getFileDate(filePath) {
+    try {
+        return statSync(filePath).mtime.toISOString().slice(0, 10);
+    }
+    catch {
+        return new Date().toISOString().slice(0, 10);
+    }
+}
+function scanProjects(initState) {
+    const results = [];
+    if (!existsSync(PROJECTS_DIR)) {
+        console.error("No Claude Code projects found at", PROJECTS_DIR);
+        return results;
+    }
+    const projectDirs = readdirSync(PROJECTS_DIR);
+    for (const dir of projectDirs) {
+        const projectId = dirToProjectId(dir);
+        if (PROJECT_FILTER && !projectId.includes(PROJECT_FILTER.toLowerCase()))
+            continue;
+        const projectPath = join(PROJECTS_DIR, dir);
+        try {
+            if (!statSync(projectPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const files = readdirSync(projectPath).filter(f => f.endsWith(".jsonl"));
+        for (const file of files) {
+            const filePath = join(projectPath, file);
+            const fileDate = getFileDate(filePath);
+            const fileKey = `${dir}/${file}`;
+            const fileSize = statSync(filePath).size;
+            if (fileSize < 100)
+                continue; // skip empty
+            // Compute content hash for dedup (check if file changed since last run)
+            const content = readFileSync(filePath, "utf8");
+            const hash = fileContentHash(content);
+            // Skip if already processed with same hash
+            const prev = initState.processed[fileKey];
+            if (prev && prev.file_hash === hash)
+                continue;
+            // Apply date filter
+            if (SINCE && fileDate < SINCE)
+                continue;
+            results.push({
+                filePath,
+                fileKey,
+                projectDir: dir,
+                projectId,
+                date: fileDate,
+                sizeBytes: fileSize,
+                fileHash: hash,
+            });
+        }
+        if (LIMIT > 0 && results.length >= LIMIT)
+            break;
+    }
+    results.sort((a, b) => a.date.localeCompare(b.date)); // chronological for daily logs
+    if (LIMIT > 0)
+        return results.slice(0, LIMIT);
+    return results;
+}
+function scanMemoryFiles(initState) {
+    const results = [];
+    // 1. Global CLAUDE.md
+    const globalClaude = join(CLAUDE_DIR, "CLAUDE.md");
+    if (existsSync(globalClaude)) {
+        const content = readFileSync(globalClaude, "utf8");
+        const hash = fileContentHash(content);
+        const prev = initState.memory_files_processed["global/CLAUDE.md"];
+        if (!prev || prev.hash !== hash) {
+            results.push({
+                filePath: globalClaude,
+                fileKey: "global/CLAUDE.md",
+                projectId: "global",
+                type: "preference",
+                title: "Global Claude Code preferences",
+                description: "Global coding guidelines and preferences for all Claude Code projects",
+                content: scrubCredentials(content),
+                hash,
+            });
+        }
+    }
+    // 2. Per-project CLAUDE.md and memory/ files
+    if (existsSync(PROJECTS_DIR)) {
+        for (const dir of readdirSync(PROJECTS_DIR)) {
+            if (PROJECT_FILTER && !dirToProjectId(dir).includes(PROJECT_FILTER.toLowerCase()))
+                continue;
+            const projectPath = join(PROJECTS_DIR, dir);
+            try {
+                if (!statSync(projectPath).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const projectId = dirToProjectId(dir);
+            // Project CLAUDE.md
+            const projectClaude = join(projectPath, "CLAUDE.md");
+            if (existsSync(projectClaude)) {
+                const content = readFileSync(projectClaude, "utf8");
+                const hash = fileContentHash(content);
+                const key = `${dir}/CLAUDE.md`;
+                const prev = initState.memory_files_processed[key];
+                if (!prev || prev.hash !== hash) {
+                    results.push({
+                        filePath: projectClaude,
+                        fileKey: key,
+                        projectId,
+                        type: "reference",
+                        title: `Project instructions: ${projectId}`,
+                        description: `Project-level instructions and conventions for ${projectId}`,
+                        content: scrubCredentials(content),
+                        hash,
+                    });
+                }
+            }
+            // Memory directory
+            const memoryDir = join(projectPath, "memory");
+            if (existsSync(memoryDir)) {
+                try {
+                    for (const memFile of readdirSync(memoryDir)) {
+                        if (!memFile.endsWith(".md"))
+                            continue;
+                        if (memFile === "MEMORY.md")
+                            continue; // index file, skip
+                        const memPath = join(memoryDir, memFile);
+                        const content = readFileSync(memPath, "utf8");
+                        const hash = fileContentHash(content);
+                        const key = `${dir}/memory/${memFile}`;
+                        const prev = initState.memory_files_processed[key];
+                        if (!prev || prev.hash !== hash) {
+                            // Parse frontmatter
+                            const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+                            const fm = fmMatch?.[1] || "";
+                            const typeMatch = fm.match(/^type:\s*(\w+)/m);
+                            const nameMatch = fm.match(/^name:\s*(.+)/m);
+                            const descMatch = fm.match(/^description:\s*(.+)/m);
+                            const memType = typeMatch?.[1] || "fact";
+                            const memName = nameMatch?.[1]?.trim() || memFile.replace(".md", "");
+                            const memDesc = descMatch?.[1]?.trim() || memName;
+                            // Strip frontmatter from body for cleaner supplementary context
+                            const bodyWithoutFm = fmMatch
+                                ? content.slice(fmMatch[0].length).trim()
+                                : content.trim();
+                            const typeMap = {
+                                user: "preference",
+                                feedback: "preference",
+                                project: "fact",
+                                reference: "reference",
+                            };
+                            results.push({
+                                filePath: memPath,
+                                fileKey: key,
+                                projectId,
+                                type: typeMap[memType] || "fact",
+                                title: memName,
+                                description: memDesc,
+                                content: scrubCredentials(bodyWithoutFm),
+                                hash,
+                            });
+                        }
+                    }
+                }
+                catch { /* memory dir read error */ }
+            }
+        }
+    }
+    return results;
+}
+// ── API helpers ─────────────────────────────────────────────────────
+async function apiCall(method, path, apiKey, apiBase, body) {
+    const res = await fetch(`${apiBase}${path}`, {
+        method,
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+            "User-Agent": "ricord-mcp/init-v2",
+        },
+        ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`${res.status}: ${text.slice(0, 200)}`);
+    }
+    return res.json();
+}
+async function ingestSegment(segment, convoDate, projectId, sessionId, segmentIndex, totalSegments, apiKey, apiBase) {
+    const result = { episodes: 0, items_saved: 0, errors: [] };
+    // Build rich content with conversation topics for the episode
+    const userLines = segment.turns
+        .filter(t => t.role === "user")
+        .map(t => t.content.slice(0, 200))
+        .slice(-8);
+    const topicSummary = userLines.length > 0
+        ? `Topics discussed:\n${userLines.map(t => `- ${t}`).join("\n")}\n\n---\n\n`
+        : "";
+    const episodeContent = `${topicSummary}${segment.context}`;
+    const segmentLabel = totalSegments > 1
+        ? ` (segment ${segmentIndex + 1}/${totalSegments}, turns ${segment.turnRange})`
+        : "";
+    try {
+        const wikiResult = await apiCall("POST", "/v1/memories", apiKey, apiBase, {
+            content: episodeContent.slice(0, 8000),
+            title: `Session ${convoDate} — ${projectId}${segmentLabel}`,
+            type: "episode",
+            tags: ["auto-init", "session-log", projectId, `session:${sessionId.slice(0, 8)}`],
+            namespace: projectId,
+            project_id: projectId,
+            source: "init",
+            session_id: sessionId,
+        });
+        result.episodes++;
+        result.items_saved++;
+        // The backend fires background tasks for fact decomposition, KB enrichment,
+        // graph extraction, and search key expansion. These happen asynchronously
+        // after the response — we don't need to wait for them.
+    }
+    catch (e) {
+        result.errors.push(`episode: ${e.message}`);
+    }
+    return result;
+}
+// ── Daily log writing ───────────────────────────────────────────────
+function ensureDailyDir() {
+    if (!existsSync(DAILY_DIR))
+        mkdirSync(DAILY_DIR, { recursive: true });
+}
+/**
+ * Write a structured daily log entry in claude-memory-compiler format.
+ *
+ * Format:
+ *   ### Session (HH:MM) — project
+ *   **Context:** One-line summary
+ *   **Key Exchanges:**
+ *   - Exchange summaries
+ *   **Topics:**
+ *   - Topic list
+ */
+function writeDailyLogEntry(date, projectId, segments, result) {
+    ensureDailyDir();
+    const logPath = join(DAILY_DIR, `${date}.md`);
+    if (!existsSync(logPath)) {
+        writeFileSync(logPath, `# Daily Log: ${date}\n\n`, "utf8");
+    }
+    const timeStr = new Date().toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
+    // Extract key exchanges and topics from segments
+    const allUserMessages = [];
+    const allAssistantMessages = [];
+    for (const seg of segments) {
+        for (const turn of seg.turns) {
+            if (turn.role === "user") {
+                allUserMessages.push(turn.content.slice(0, 200));
+            }
+            else {
+                allAssistantMessages.push(turn.content.slice(0, 200));
+            }
+        }
+    }
+    // Build structured entry
+    const lines = [];
+    lines.push(`### Session (${timeStr}) — ${projectId}`);
+    lines.push("");
+    // Context line
+    const firstUserMsg = allUserMessages[0] || "Coding session";
+    lines.push(`**Context:** ${firstUserMsg.slice(0, 120)}`);
+    lines.push("");
+    // Key exchanges (user questions/requests, max 5)
+    const keyExchanges = allUserMessages
+        .filter(m => m.length > 20) // skip short confirmations
+        .slice(0, 5);
+    if (keyExchanges.length > 0) {
+        lines.push("**Key Exchanges:**");
+        for (const exchange of keyExchanges) {
+            lines.push(`- ${exchange.slice(0, 150)}`);
+        }
+        lines.push("");
+    }
+    // Decisions (look for decision-like patterns in assistant messages)
+    const decisions = allAssistantMessages
+        .filter(m => /(?:decided|chose|using|switched|went with|will use|recommend|should)/i.test(m) &&
+        m.length > 30)
+        .slice(0, 3);
+    if (decisions.length > 0) {
+        lines.push("**Decisions Made:**");
+        for (const decision of decisions) {
+            lines.push(`- ${decision.slice(0, 150)}`);
+        }
+        lines.push("");
+    }
+    // Stats
+    lines.push(`**Stats:** ${result.turns} turns, ${segments.length} segments, ` +
+        `${result.episodes} episodes, ${result.items_saved} items saved`);
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    appendFileSync(logPath, lines.join("\n"), "utf8");
+}
+// ── Memory file ingestion ───────────────────────────────────────────
+async function ingestMemoryFile(memFile, apiKey, apiBase) {
+    try {
+        // Send frontmatter-stripped body as embedding content. More tokens = richer
+        // semantic surface for varied query phrasings. Frontmatter YAML was the
+        // actual noise; description is redundant with the body's first line.
+        const embeddingContent = (memFile.content.trim() || memFile.description).slice(0, 8000);
+        await apiCall("POST", "/v1/memories", apiKey, apiBase, {
+            content: embeddingContent,
+            title: memFile.title,
+            type: memFile.type,
+            tags: ["auto-init", "memory-file", memFile.projectId],
+            namespace: memFile.projectId,
+            project_id: memFile.projectId,
+            source: "init-memory",
+        });
+        return true;
+    }
+    catch (e) {
+        process.stderr.write(`\n    ! ${memFile.fileKey}: ${e.message.slice(0, 100)}\n`);
+        return false;
+    }
+}
+// ── Compilation pass (KB refresh) ───────────────────────────────────
+async function runCompilationPass(apiKey, apiBase) {
+    console.log("\nRunning compilation pass...");
+    // 1. List all KB pages
+    let pages = [];
+    try {
+        const kbResult = await apiCall("GET", "/v1/kb/pages?limit=100", apiKey, apiBase);
+        pages = kbResult.pages || [];
+        console.log(`  Found ${pages.length} KB pages`);
+    }
+    catch (e) {
+        console.error(`  KB listing failed: ${e.message}`);
+        return;
+    }
+    // 2. Refresh stale pages
+    let refreshed = 0;
+    const stalePages = pages.filter(p => p.status === "stale" || p.status === "draft");
+    for (const page of stalePages.slice(0, 20)) { // limit to 20 refreshes per run
+        try {
+            await apiCall("POST", `/v1/kb/pages/${encodeURIComponent(page.id)}/refresh`, apiKey, apiBase, {});
+            refreshed++;
+            process.stdout.write(`\r  Refreshing KB pages... ${refreshed}/${stalePages.length}`);
+        }
+        catch { /* best effort */ }
+        await sleep(300); // rate limit
+    }
+    if (refreshed > 0) {
+        console.log(`\n  Refreshed ${refreshed} KB pages`);
+    }
+    else {
+        console.log("  All KB pages up to date");
+    }
+    // 3. Run lint
+    try {
+        const lintResult = await apiCall("POST", "/v1/kb/lint", apiKey, apiBase, {});
+        const issues = lintResult.issues || [];
+        if (issues.length > 0) {
+            console.log(`  Lint: ${issues.length} issues found`);
+            for (const issue of issues.slice(0, 5)) {
+                console.log(`    - [${issue.type}] ${issue.message}`);
+            }
+        }
+        else {
+            console.log("  Lint: all checks passed");
+        }
+    }
+    catch { /* best effort */ }
+}
+// ── Helpers ─────────────────────────────────────────────────────────
+function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+// ── Main ────────────────────────────────────────────────────────────
+async function main() {
+    if (MEMORY_ONLY) {
+        console.log("ricord init — Memory-file sync\n");
+    }
+    else {
+        console.log("ricord init — Full conversation-to-knowledge compiler\n");
+    }
+    const initState = loadInitState();
+    const conversations = MEMORY_ONLY ? [] : scanProjects(initState);
+    const memoryFiles = INCLUDE_MEMORY ? scanMemoryFiles(initState) : [];
+    // ── Summary ─────────────────────────────────────────────────────
+    if (conversations.length === 0 && memoryFiles.length === 0) {
+        console.log("No new conversations or memory files to process.");
+        if (PROJECT_FILTER)
+            console.log(`  (filtered by --project ${PROJECT_FILTER})`);
+        if (SINCE)
+            console.log(`  (filtered by --since ${SINCE})`);
+        if (Object.keys(initState.processed).length > 0) {
+            console.log(`  (${Object.keys(initState.processed).length} conversations already processed)`);
+            console.log(`  To reprocess, delete ${INIT_STATE_FILE}`);
+        }
+        if (!INCLUDE_MEMORY) {
+            console.log(`  Use --include-memory to also process ~/.claude memory files`);
+        }
+        return;
+    }
+    // Group by project for display
+    const byProject = new Map();
+    for (const c of conversations) {
+        const list = byProject.get(c.projectId) || [];
+        list.push(c);
+        byProject.set(c.projectId, list);
+    }
+    console.log(`Found ${conversations.length} new conversations across ${byProject.size} projects:`);
+    for (const [projectId, convos] of byProject) {
+        const totalSize = convos.reduce((s, c) => s + c.sizeBytes, 0);
+        console.log(`  ${projectId}: ${convos.length} conversations (${formatBytes(totalSize)})`);
+    }
+    if (memoryFiles.length > 0) {
+        console.log(`\nFound ${memoryFiles.length} memory files to process`);
+    }
+    console.log(`\nPipeline: segments → episodes → facts → KB → graph`);
+    console.log(`Mode: full pipeline (layers=all)`);
+    if (DRY_RUN) {
+        console.log("\n[dry-run] Would process these conversations:");
+        for (const c of conversations.slice(0, 30)) {
+            const turns = parseAllTurns(c.filePath);
+            const segments = segmentConversation(turns);
+            const userTurns = turns.filter(t => t.role === "user").length;
+            console.log(`  ${c.date} | ${c.projectId} | ${turns.length} turns (${userTurns} user) | ` +
+                `${segments.length} segments | ${formatBytes(c.sizeBytes)}`);
+        }
+        if (conversations.length > 30) {
+            console.log(`  ... and ${conversations.length - 30} more`);
+        }
+        if (memoryFiles.length > 0) {
+            console.log("\n[dry-run] Would process these memory files:");
+            for (const m of memoryFiles) {
+                console.log(`  ${m.projectId} | [${m.type}] ${m.title}`);
+            }
+        }
+        return;
+    }
+    // ── Credentials ─────────────────────────────────────────────────
+    // Auto-spawn the same `ricord-mcp login` browser flow if no creds found,
+    // then continue init. Single command instead of forcing the user to run
+    // login → re-run init manually.
+    let creds = loadCredentials();
+    if (!creds) {
+        console.log("\nNo Ricord credentials found — launching browser login...\n");
+        const cliPath = fileURLToPath(import.meta.url).replace(/init\.js$/, "index.js");
+        const result = spawnSync(process.execPath, [cliPath, "login"], { stdio: "inherit" });
+        if (result.status !== 0) {
+            console.error("\nLogin failed or cancelled. Run `npx ricord-mcp login` then re-run init.");
+            process.exit(1);
+        }
+        creds = loadCredentials();
+        if (!creds) {
+            console.error("\nLogin completed but credentials file not found. Aborting init.");
+            process.exit(1);
+        }
+        console.log(""); // spacer between login output and init progress
+    }
+    const apiBase = creds.api_base || "https://api.ricord.ai";
+    // ── Process conversations ───────────────────────────────────────
+    let totalEpisodes = 0;
+    let totalItems = 0;
+    let totalTurns = 0;
+    let totalErrors = 0;
+    let totalSegments = 0;
+    console.log("\nProcessing conversations...\n");
+    for (let i = 0; i < conversations.length; i++) {
+        const c = conversations[i];
+        const pct = ((i + 1) / conversations.length * 100).toFixed(0);
+        process.stdout.write(`  [${pct}%] ${i + 1}/${conversations.length} — ${c.projectId}/${c.date}`);
+        try {
+            // Step 1: Parse ALL turns
+            const turns = parseAllTurns(c.filePath);
+            const userTurns = turns.filter(t => t.role === "user").length;
+            if (userTurns < 2) {
+                process.stdout.write(" (skipped: <2 user turns)\n");
+                continue;
+            }
+            // Step 2: Generate stable session ID from file hash
+            const sessionId = c.fileHash;
+            // Step 3: Segment the conversation
+            const segments = segmentConversation(turns);
+            totalSegments += segments.length;
+            process.stdout.write(` — ${turns.length} turns, ${segments.length} segments`);
+            // Step 4: Process each segment through the full pipeline
+            let convoEpisodes = 0;
+            let convoItems = 0;
+            const convoErrors = [];
+            for (let si = 0; si < segments.length; si++) {
+                const seg = segments[si];
+                if (seg.userTurnCount === 0)
+                    continue; // skip assistant-only segments
+                const segResult = await ingestSegment(seg, c.date, c.projectId, sessionId, si, segments.length, creds.api_key, apiBase);
+                convoEpisodes += segResult.episodes;
+                convoItems += segResult.items_saved;
+                convoErrors.push(...segResult.errors);
+                // Rate limiting between segments
+                if (si < segments.length - 1) {
+                    await sleep(BATCH_DELAY_MS);
+                }
+            }
+            // Step 5: Write daily log entry
+            writeDailyLogEntry(c.date, c.projectId, segments, {
+                episodes: convoEpisodes,
+                items_saved: convoItems,
+                turns: turns.length,
+            });
+            totalEpisodes += convoEpisodes;
+            totalItems += convoItems;
+            totalTurns += turns.length;
+            totalErrors += convoErrors.length;
+            for (const err of convoErrors) {
+                process.stderr.write(`\n    ! ${err}\n`);
+            }
+            process.stdout.write(` — ${convoEpisodes} episodes saved\n`);
+            // Update state
+            initState.processed[c.fileKey] = {
+                date: c.date,
+                items_saved: convoItems,
+                turns_ingested: turns.length,
+                segments: segments.length,
+                file_hash: c.fileHash,
+            };
+            // Save state periodically
+            if ((i + 1) % 10 === 0) {
+                initState.last_run = new Date().toISOString();
+                saveInitState(initState);
+            }
+        }
+        catch (e) {
+            totalErrors++;
+            process.stderr.write(` — ERROR: ${e.message.slice(0, 100)}\n`);
+        }
+        await sleep(BATCH_DELAY_MS);
+    }
+    // ── Process memory files ────────────────────────────────────────
+    if (memoryFiles.length > 0) {
+        console.log(`\nProcessing ${memoryFiles.length} memory files...`);
+        let memSaved = 0;
+        for (let i = 0; i < memoryFiles.length; i++) {
+            const m = memoryFiles[i];
+            process.stdout.write(`  [${i + 1}/${memoryFiles.length}] ${m.title}...`);
+            const ok = await ingestMemoryFile(m, creds.api_key, apiBase);
+            if (ok) {
+                memSaved++;
+                process.stdout.write(" saved\n");
+            }
+            else {
+                process.stdout.write(" failed\n");
+            }
+            initState.memory_files_processed[m.fileKey] = {
+                date: new Date().toISOString().slice(0, 10),
+                hash: m.hash,
+            };
+            await sleep(BATCH_DELAY_MS);
+        }
+        totalItems += memSaved;
+        console.log(`  Memory files saved: ${memSaved}/${memoryFiles.length}`);
+    }
+    // ── Compilation pass ────────────────────────────────────────────
+    if (RUN_COMPILE) {
+        await runCompilationPass(creds.api_key, apiBase);
+    }
+    // ── Save final state ────────────────────────────────────────────
+    initState.total_episodes += totalEpisodes;
+    initState.total_items += totalItems;
+    initState.total_turns += totalTurns;
+    initState.last_run = new Date().toISOString();
+    initState.runs++;
+    saveInitState(initState);
+    // ── Summary ─────────────────────────────────────────────────────
+    console.log("\n" + "=".repeat(50));
+    console.log("Init complete!\n");
+    console.log(`  Conversations processed: ${conversations.length}`);
+    console.log(`  Total turns parsed:      ${totalTurns}`);
+    console.log(`  Segments created:        ${totalSegments}`);
+    console.log(`  Episodes saved:          ${totalEpisodes}`);
+    console.log(`  Total items:             ${totalItems}`);
+    if (totalErrors > 0)
+        console.log(`  Errors:                  ${totalErrors}`);
+    console.log(`  Projects:                ${[...byProject.keys()].join(", ")}`);
+    console.log(`  Daily logs written:      ${DAILY_DIR}`);
+    console.log(`\n  Pipeline layers triggered per segment:`);
+    console.log(`    - Atomic fact decomposition (rule-based)`);
+    console.log(`    - Knowledge graph entity extraction`);
+    console.log(`    - KB page enrichment (500-2000 word wiki articles)`);
+    console.log(`    - Search key expansion (+9.4% recall)`);
+    console.log(`    - Conflict detection + resolution`);
+    console.log(`\n  All-time stats (${initState.runs} runs):`);
+    console.log(`    Conversations: ${Object.keys(initState.processed).length}`);
+    console.log(`    Episodes:      ${initState.total_episodes}`);
+    console.log(`    Items:         ${initState.total_items}`);
+    if (!RUN_COMPILE) {
+        console.log(`\n  Tip: Run with --compile or --full to also refresh KB pages`);
+    }
+    if (!INCLUDE_MEMORY) {
+        console.log(`  Tip: Run with --include-memory or --full to ingest ~/.claude memory files`);
+    }
+    console.log(`\n  To reprocess everything: rm ${INIT_STATE_FILE}`);
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=init.js.map