@fs/mycroft 0.2.0 → 0.3.0

package/dist/main-36PRDAPE.js

@@ -0,0 +1,1857 @@
+import {
+  CHUNK_OVERLAP,
+  CHUNK_SIZE,
+  SEPARATORS,
+  SUMMARY_CONCURRENCY,
+  SUMMARY_MAX_TOKENS,
+  SUMMARY_TARGET_WORDS,
+  configPath,
+  ensureConfigDirs,
+  ensureDataDirs,
+  getModels,
+  handleSigint,
+  isAskEnabled,
+  isInteractive,
+  loadConfig,
+  logInfo,
+  logWarn,
+  printError,
+  requireOpenAIKey,
+  resolvePaths,
+  setConfigOverrides,
+  stdout,
+  submitBatchEmbeddings
+} from "./chunk-6DLQHHCC.js";
+
+// src/main.ts
+import { Command } from "commander";
+import { readFile as readFile2 } from "fs/promises";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/services/epub-parser.ts
+import { initEpubFile } from "@lingo-reader/epub-parser";
+import { basename } from "path";
+var detectNarrativeBoundaries = (chapterTitles) => {
+  const frontMatterPattern = /^(about|contents|table of contents|dedication|preface|foreword|title|half.?title|copyright|epigraph|frontispiece|map)/i;
+  const backMatterPattern = /^(acknowledgment|afterword|appendix|glossary|index|bibliography|about the author|also by|praise|copyright page|notes|bonus|preview|excerpt|major characters|locations)/i;
+  const narrativePattern = /^(I|II|III|IV|V|VI|VII|VIII|IX|X|XI|XII|1|2|3|4|5|6|7|8|9|one|two|three|chapter|prologue|epilogue|part\s)/i;
+  let start = 0;
+  let end = chapterTitles.length - 1;
+  for (let i = 0; i < chapterTitles.length; i++) {
+    const title = chapterTitles[i]?.trim() || "";
+    if (narrativePattern.test(title) && !frontMatterPattern.test(title)) {
+      start = i;
+      break;
+    }
+    if (!frontMatterPattern.test(title) && title.length > 0) {
+      if (title.length > 3) {
+        start = i;
+        break;
+      }
+    }
+  }
+  for (let i = chapterTitles.length - 1; i >= start; i--) {
+    const title = chapterTitles[i]?.trim() || "";
+    if (!backMatterPattern.test(title)) {
+      end = i;
+      break;
+    }
+  }
+  logInfo(`[EPUB Parser] Detected narrative boundaries: chapters ${start} to ${end} (out of ${chapterTitles.length} total)`);
+  if (start > 0) {
+    logInfo(`[EPUB Parser] Front matter: ${chapterTitles.slice(0, start).join(", ")}`);
+  }
+  if (end < chapterTitles.length - 1) {
+    logInfo(`[EPUB Parser] Back matter: ${chapterTitles.slice(end + 1).join(", ")}`);
+  }
+  return { start, end };
+};
+var stripHtml = (html) => html.replace(/<script[\s\S]*?<\/script>/gi, " ").replace(/<style[\s\S]*?<\/style>/gi, " ").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
+var originalWarn = console.warn;
+var createWarnFilter = () => {
+  const suppressedWarnings = [];
+  console.warn = (msg, ...args) => {
+    if (typeof msg === "string" && msg.includes("No element with id") && msg.includes("parsing <metadata>")) {
+      suppressedWarnings.push(msg);
+      return;
+    }
+    originalWarn(msg, ...args);
+  };
+  return suppressedWarnings;
+};
+var parseEpub = async (epubPath, resourceSaveDir) => {
+  logInfo(`[EPUB Parser] Starting parse for: ${basename(epubPath)}`);
+  const suppressedWarnings = createWarnFilter();
+  try {
+    const epubFile = await initEpubFile(epubPath, resourceSaveDir);
+    await epubFile.loadEpub();
+    logInfo(`[EPUB Parser] EPUB loaded successfully`);
+    await epubFile.parse();
+    if (suppressedWarnings.length > 0) {
+      logInfo(`[EPUB Parser] Suppressed ${suppressedWarnings.length} metadata warnings (non-critical)`);
+    }
+    logInfo(`[EPUB Parser] Parse completed`);
+    const fileBaseName = basename(epubPath, ".epub");
+    let metadata = null;
+    try {
+      metadata = epubFile.getMetadata();
+    } catch {
+      metadata = null;
+    }
+    const safeMetadata = metadata ?? {};
+    const spine = epubFile.getSpine();
+    const toc = epubFile.getToc();
+    logInfo(`[EPUB Parser] Found ${spine.length} spine items, ${toc.length} TOC entries`);
+    const titleById = /* @__PURE__ */ new Map();
+    const walkToc = (items) => {
+      items.forEach((item) => {
+        const resolved = epubFile.resolveHref(item.href);
+        if (resolved?.id) titleById.set(resolved.id, item.label);
+        if (item.children?.length) walkToc(item.children);
+      });
+    };
+    walkToc(toc);
+    const coverImagePath = epubFile.getCoverImage() || null;
+    const chapters = [];
+    const chapterTitles = [];
+    for (const [index, item] of spine.entries()) {
+      const chapter = await epubFile.loadChapter(item.id);
+      const content = stripHtml(chapter.html);
+      if (!content) continue;
+      const chapterTitle = titleById.get(item.id) || item.id || `Chapter ${index + 1}`;
+      chapters.push({
+        title: chapterTitle,
+        content
+      });
+      chapterTitles.push(chapterTitle);
+    }
+    epubFile.destroy();
+    const author = safeMetadata.creator?.[0]?.contributor ?? null;
+    logInfo(`[EPUB Parser] Extracted ${chapters.length} chapters with content`);
+    logInfo(`[EPUB Parser] Title: "${safeMetadata.title || fileBaseName || "Untitled"}", Author: "${author || "Unknown"}"`);
+    const { start: narrativeStartIndex, end: narrativeEndIndex } = detectNarrativeBoundaries(chapterTitles);
+    return {
+      title: safeMetadata.title || fileBaseName || "Untitled",
+      author,
+      coverImagePath,
+      chapters,
+      chapterTitles,
+      narrativeStartIndex,
+      narrativeEndIndex
+    };
+  } finally {
+    console.warn = originalWarn;
+  }
+};
+
+// src/services/ingest.ts
+import { randomUUID } from "crypto";
+import { mkdir, unlink, copyFile, readFile, writeFile } from "fs/promises";
+
+// src/services/chunker.ts
+var splitRecursive = (text, separators) => {
+  if (text.length <= CHUNK_SIZE || separators.length === 0) return [text];
+  const [separator, ...rest] = separators;
+  if (!separator) return [text];
+  const parts = text.split(separator);
+  if (parts.length === 1) return splitRecursive(text, rest);
+  const chunks = [];
+  let current = "";
+  for (const part of parts) {
+    const next = current ? `${current}${separator}${part}` : part;
+    if (next.length <= CHUNK_SIZE) {
+      current = next;
+      continue;
+    }
+    if (current) chunks.push(current);
+    current = part;
+  }
+  if (current) chunks.push(current);
+  const refined = [];
+  for (const chunk of chunks) {
+    if (chunk.length <= CHUNK_SIZE) {
+      refined.push(chunk);
+      continue;
+    }
+    refined.push(...splitRecursive(chunk, rest));
+  }
+  return refined;
+};
+var withOverlap = (chunks) => {
+  if (chunks.length <= 1 || CHUNK_OVERLAP === 0) return chunks;
+  const merged = [];
+  for (let i = 0; i < chunks.length; i += 1) {
+    const current = chunks[i] ?? "";
+    const previous = merged[merged.length - 1];
+    if (!previous) {
+      merged.push(current);
+      continue;
+    }
+    const overlap = previous.slice(-CHUNK_OVERLAP);
+    merged.push(`${overlap}${current}`);
+  }
+  return merged;
+};
+var chunkChapters = (bookId, chapters) => {
+  const chunks = [];
+  chapters.forEach((chapter, chapterIndex) => {
+    const trimmed = chapter.content.trim();
+    if (!trimmed) return;
+    const rawChunks = splitRecursive(trimmed, SEPARATORS);
+    const overlapped = withOverlap(rawChunks);
+    overlapped.forEach((content, chunkIndex) => {
+      const normalized = content.replace(/\s+/g, " ").trim();
+      if (!normalized) return;
+      chunks.push({
+        id: `${bookId}-${chapterIndex}-${chunkIndex}`,
+        bookId,
+        chapterIndex,
+        chapterTitle: chapter.title,
+        chunkIndex,
+        content: normalized
+      });
+    });
+  });
+  return chunks;
+};
+
+// src/services/embedder.ts
+import { embedMany } from "ai";
+import { openai } from "@ai-sdk/openai";
+var MAX_TOKENS_PER_BATCH = 25e4;
+var CHARS_PER_TOKEN = 4;
+var embedChunks = async (chunks, options) => {
+  if (chunks.length === 0) return [];
+  const batches = [];
+  let currentBatch = [];
+  let currentTokens = 0;
+  for (const chunk of chunks) {
+    const estimatedTokens = Math.ceil(chunk.content.length / CHARS_PER_TOKEN);
+    if (currentTokens + estimatedTokens > MAX_TOKENS_PER_BATCH && currentBatch.length > 0) {
+      batches.push(currentBatch);
+      currentBatch = [];
+      currentTokens = 0;
+    }
+    currentBatch.push(chunk);
+    currentTokens += estimatedTokens;
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  logInfo(`[Embedder] Processing ${chunks.length} chunks in ${batches.length} batch(es)`);
+  const allEmbedded = [];
+  const models = await getModels();
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    const estimatedTokens = batch.reduce((sum, c) => sum + Math.ceil(c.content.length / CHARS_PER_TOKEN), 0);
+    logInfo(`[Embedder] Batch ${i + 1}/${batches.length}: ${batch.length} chunks (~${estimatedTokens.toLocaleString()} tokens)`);
+    const { embeddings } = await embedMany({
+      model: openai.embeddingModel(models.embedding),
+      values: batch.map((chunk) => chunk.content)
+    });
+    const embeddedBatch = [];
+    for (let j = 0; j < batch.length; j++) {
+      const embeddedChunk = {
+        ...batch[j],
+        vector: embeddings[j] ?? []
+      };
+      embeddedBatch.push(embeddedChunk);
+      allEmbedded.push({
+        ...embeddedChunk
+      });
+    }
+    if (options?.onBatch) {
+      await options.onBatch(embeddedBatch, {
+        batchIndex: i + 1,
+        batchCount: batches.length,
+        completed: allEmbedded.length,
+        total: chunks.length
+      });
+    }
+  }
+  logInfo(`[Embedder] Successfully embedded all ${allEmbedded.length} chunks`);
+  return allEmbedded;
+};
+
+// src/services/vector-store.ts
+import { LocalIndex } from "vectra";
+var indexPathForBook = async (bookId) => {
+  const paths = await ensureDataDirs();
+  return `${paths.vectorsDir}/${bookId}`;
+};
+var createBookIndex = async (bookId) => {
+  const index = new LocalIndex(await indexPathForBook(bookId));
+  const exists = await index.isIndexCreated();
+  if (!exists) {
+    await index.createIndex({
+      version: 1,
+      metadata_config: {
+        indexed: ["bookId"]
+      }
+    });
+  }
+  return index;
+};
+var addChunksToIndex = async (bookId, chunks) => {
+  const index = await createBookIndex(bookId);
+  await index.batchInsertItems(
+    chunks.map((chunk) => ({
+      id: chunk.id,
+      vector: chunk.vector,
+      metadata: {
+        bookId: chunk.bookId,
+        chapterIndex: chunk.chapterIndex,
+        chapterTitle: chunk.chapterTitle,
+        chunkIndex: chunk.chunkIndex,
+        content: chunk.content,
+        type: chunk.type || "chunk"
+      }
+    }))
+  );
+};
+var queryBookIndex = async (bookId, queryVector, queryText, topK, maxChapterIndex) => {
+  const index = await createBookIndex(bookId);
+  const expandedTopK = maxChapterIndex === void 0 || maxChapterIndex === null ? topK : Math.max(topK * 4, topK);
+  const results = await index.queryItems(queryVector, queryText, expandedTopK);
+  const mapped = results.map((result) => ({
+    id: result.item.id ?? "",
+    bookId,
+    chapterIndex: result.item.metadata?.chapterIndex ?? 0,
+    chapterTitle: result.item.metadata?.chapterTitle ?? "",
+    chunkIndex: result.item.metadata?.chunkIndex ?? 0,
+    content: result.item.metadata?.content ?? "",
+    type: result.item.metadata?.type,
+    score: result.score
+  }));
+  if (maxChapterIndex === void 0 || maxChapterIndex === null) {
+    return mapped.slice(0, topK);
+  }
+  return mapped.filter((item) => item.chapterIndex <= maxChapterIndex).slice(0, topK);
+};
+var deleteBookIndex = async (bookId) => {
+  const index = new LocalIndex(await indexPathForBook(bookId));
+  const exists = await index.isIndexCreated();
+  if (!exists) return;
+  await index.deleteIndex();
+};
+
+// src/services/summarizer.ts
+import { generateText } from "ai";
+import { openai as openai2 } from "@ai-sdk/openai";
+var CHARS_PER_TOKEN2 = 4;
+var estimateTokens = (text) => Math.ceil(text.length / CHARS_PER_TOKEN2);
+var SUMMARY_PROMPT = (title, chapterNum, content) => `You are analyzing a chapter from a book (fiction or nonfiction). Extract key information to help readers understand the chapter's content.
+
+Chapter Title: ${title}
+Chapter Number: ${chapterNum}
+
+---
+${content}
+---
+
+Extract the following information and respond ONLY with valid JSON (no markdown, no code blocks):
+
+{
+  "characters": ["Name - brief description (role, traits, first appearance)", ...],
+  "events": "What happens in this chapter? (2-3 sentences)",
+  "setting": "Where does this chapter take place?",
+  "revelations": "Any important information revealed? (secrets, backstory, foreshadowing)"
+}
+
+Keep the total response around ${SUMMARY_TARGET_WORDS} words.`;
+var splitIntoSections = (text, maxTokens) => {
+  const estimatedTokens = estimateTokens(text);
+  if (estimatedTokens <= maxTokens) {
+    return [text];
+  }
+  const numSections = Math.ceil(estimatedTokens / maxTokens);
+  const charsPerSection = Math.floor(text.length / numSections);
+  const sections = [];
+  for (let i = 0; i < numSections; i++) {
+    const start = i * charsPerSection;
+    const end = i === numSections - 1 ? text.length : (i + 1) * charsPerSection;
+    sections.push(text.slice(start, end));
+  }
+  return sections;
+};
+var summarizeSection = async (text, title, sectionNum) => {
+  const models = await getModels();
+  const { text: summary } = await generateText({
+    model: openai2(models.summary),
+    prompt: `Summarize this section from chapter "${title}" (Part ${sectionNum}). Focus on key events, characters, and revelations. Keep it concise (100-150 words):
+
+${text}`,
+    temperature: 0.3
+  });
+  return summary;
+};
+var generateStructuredSummary = async (content, title, chapterIndex) => {
+  try {
+    const models = await getModels();
+    const { text } = await generateText({
+      model: openai2(models.summary),
+      prompt: SUMMARY_PROMPT(title, chapterIndex + 1, content),
+      temperature: 0.3
+    });
+    let jsonText = text.trim();
+    if (jsonText.startsWith("```json")) {
+      jsonText = jsonText.slice(7, -3).trim();
+    } else if (jsonText.startsWith("```")) {
+      jsonText = jsonText.slice(3, -3).trim();
+    }
+    const parsed = JSON.parse(jsonText);
+    const fullSummary = `Chapter ${chapterIndex + 1}: ${title}
+
+Characters: ${parsed.characters.join(", ")}
+
+Events: ${parsed.events}
+
+Setting: ${parsed.setting}
+
+Revelations: ${parsed.revelations}`;
+    return {
+      chapterIndex,
+      chapterTitle: title,
+      characters: parsed.characters,
+      events: parsed.events,
+      setting: parsed.setting,
+      revelations: parsed.revelations,
+      fullSummary
+    };
+  } catch (error) {
+    logWarn(`[Summarizer] Failed to parse summary JSON for "${title}": ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+};
+var summarizeChapter = async (chapter, chapterIndex) => {
+  const tokens = estimateTokens(chapter.content);
+  logInfo(`[Summarizer] Chapter ${chapterIndex + 1} "${chapter.title}": ~${tokens.toLocaleString()} tokens`);
+  try {
+    if (tokens < SUMMARY_MAX_TOKENS) {
+      return await generateStructuredSummary(chapter.content, chapter.title, chapterIndex);
+    }
+    logInfo(`[Summarizer] Chapter ${chapterIndex + 1} exceeds token limit, using two-pass approach`);
+    const sections = splitIntoSections(chapter.content, SUMMARY_MAX_TOKENS);
+    logInfo(`[Summarizer] Split into ${sections.length} sections`);
+    const sectionSummaries = await Promise.all(
+      sections.map((section, i) => summarizeSection(section, chapter.title, i + 1))
+    );
+    const combined = sectionSummaries.join("\n\n");
+    return await generateStructuredSummary(combined, chapter.title, chapterIndex);
+  } catch (error) {
+    logWarn(`[Summarizer] Failed to summarize chapter ${chapterIndex + 1}: ${error instanceof Error ? error.message : String(error)}`);
+    return null;
+  }
+};
+var summarizeAllChapters = async (chapters, options) => {
+  const summaries = [];
+  const concurrency = options?.batch ? 1 : SUMMARY_CONCURRENCY;
+  logInfo(
+    `[Summarizer] Starting summarization of ${chapters.length} chapters (concurrency: ${concurrency}${options?.batch ? ", batch mode" : ""})`
+  );
+  for (let i = 0; i < chapters.length; i += concurrency) {
+    const batch = chapters.slice(i, i + concurrency);
+    const batchPromises = batch.map((chapter, batchIndex) => summarizeChapter(chapter, i + batchIndex));
+    const batchResults = await Promise.all(batchPromises);
+    for (const summary of batchResults) {
+      if (summary) {
+        summaries.push(summary);
+      }
+    }
+    logInfo(`[Summarizer] Progress: ${Math.min(i + concurrency, chapters.length)}/${chapters.length} chapters processed`);
+  }
+  logInfo(`[Summarizer] Completed: ${summaries.length}/${chapters.length} summaries generated`);
+  return summaries;
+};
+
+// src/db/queries.ts
+import "better-sqlite3";
+
+// src/db/schema.ts
+import Database from "better-sqlite3";
+var resolveDbPath = async () => {
+  const paths = await resolvePaths();
+  return paths.dbPath;
+};
+var createDb = async () => {
+  const db = new Database(await resolveDbPath());
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS books (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      author TEXT,
+      cover_path TEXT,
+      chapters TEXT,
+      epub_path TEXT NOT NULL,
+      chunk_count INTEGER DEFAULT 0,
+      created_at INTEGER DEFAULT (strftime('%s','now')),
+      indexed_at INTEGER,
+      progress_chapter INTEGER
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_sessions (
+      id TEXT PRIMARY KEY,
+      book_id TEXT NOT NULL,
+      title TEXT,
+      summary TEXT,
+      created_at INTEGER DEFAULT (strftime('%s','now')),
+      updated_at INTEGER DEFAULT (strftime('%s','now'))
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS chat_messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      token_count INTEGER,
+      created_at INTEGER DEFAULT (strftime('%s','now'))
+    );
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS chat_messages_session_idx ON chat_messages(session_id, created_at)");
+  const columns = db.prepare("PRAGMA table_info(books)").all().map((col) => col.name);
+  const ensureColumn = (name, definition) => {
+    if (!columns.includes(name)) {
+      db.exec(`ALTER TABLE books ADD COLUMN ${definition}`);
+    }
+  };
+  ensureColumn("chapters", "chapters TEXT");
+  ensureColumn("progress_chapter", "progress_chapter INTEGER");
+  ensureColumn("summaries", "summaries TEXT");
+  ensureColumn("narrative_start_index", "narrative_start_index INTEGER DEFAULT 0");
+  ensureColumn("narrative_end_index", "narrative_end_index INTEGER");
+  ensureColumn("batch_id", "batch_id TEXT");
+  ensureColumn("batch_file_id", "batch_file_id TEXT");
+  ensureColumn("batch_chunks", "batch_chunks TEXT");
+  ensureColumn("ingest_state", "ingest_state TEXT");
+  ensureColumn("ingest_resume_path", "ingest_resume_path TEXT");
+  return db;
+};
+
+// src/db/queries.ts
+var mapRow = (row) => ({
+  id: row.id,
+  title: row.title,
+  author: row.author ?? null,
+  coverPath: row.cover_path ?? null,
+  epubPath: row.epub_path,
+  chunkCount: row.chunk_count ?? 0,
+  createdAt: row.created_at ?? 0,
+  indexedAt: row.indexed_at ?? null,
+  chapters: row.chapters ? JSON.parse(row.chapters) : [],
+  progressChapter: row.progress_chapter ?? null,
+  narrativeStartIndex: row.narrative_start_index ?? null,
+  narrativeEndIndex: row.narrative_end_index ?? null,
+  batchId: row.batch_id ?? null,
+  batchFileId: row.batch_file_id ?? null,
+  ingestState: row.ingest_state ?? null,
+  ingestResumePath: row.ingest_resume_path ?? null
+});
+var dbPromise = null;
+var getDb = async () => {
+  if (!dbPromise) {
+    dbPromise = createDb();
+  }
+  return dbPromise;
+};
+var insertBook = async (book) => {
+  const db = await getDb();
+  const statement = db.prepare(
+    "INSERT INTO books (id, title, author, cover_path, chapters, epub_path, chunk_count, indexed_at, progress_chapter, narrative_start_index, narrative_end_index) VALUES (@id, @title, @author, @coverPath, @chapters, @epubPath, @chunkCount, @indexedAt, @progressChapter, @narrativeStartIndex, @narrativeEndIndex)"
+  );
+  statement.run({
+    id: book.id,
+    title: book.title,
+    author: book.author,
+    coverPath: book.coverPath,
+    chapters: JSON.stringify(book.chapters ?? []),
+    epubPath: book.epubPath,
+    chunkCount: book.chunkCount ?? 0,
+    indexedAt: book.indexedAt ?? null,
+    progressChapter: book.progressChapter ?? null,
+    narrativeStartIndex: book.narrativeStartIndex ?? null,
+    narrativeEndIndex: book.narrativeEndIndex ?? null
+  });
+  return book.id;
+};
+var updateBook = async (id, updates) => {
+  const fields = [];
+  const params = { id };
+  if (updates.title !== void 0) {
+    fields.push("title = @title");
+    params.title = updates.title;
+  }
+  if (updates.author !== void 0) {
+    fields.push("author = @author");
+    params.author = updates.author;
+  }
+  if (updates.coverPath !== void 0) {
+    fields.push("cover_path = @coverPath");
+    params.coverPath = updates.coverPath;
+  }
+  if (updates.chapters !== void 0) {
+    fields.push("chapters = @chapters");
+    params.chapters = JSON.stringify(updates.chapters);
+  }
+  if (updates.epubPath !== void 0) {
+    fields.push("epub_path = @epubPath");
+    params.epubPath = updates.epubPath;
+  }
+  if (updates.chunkCount !== void 0) {
+    fields.push("chunk_count = @chunkCount");
+    params.chunkCount = updates.chunkCount;
+  }
+  if (updates.indexedAt !== void 0) {
+    fields.push("indexed_at = @indexedAt");
+    params.indexedAt = updates.indexedAt;
+  }
+  if (updates.progressChapter !== void 0) {
+    fields.push("progress_chapter = @progressChapter");
+    params.progressChapter = updates.progressChapter;
+  }
+  if (updates.summaries !== void 0) {
+    fields.push("summaries = @summaries");
+    params.summaries = updates.summaries;
+  }
+  if (updates.narrativeStartIndex !== void 0) {
+    fields.push("narrative_start_index = @narrativeStartIndex");
+    params.narrativeStartIndex = updates.narrativeStartIndex;
+  }
+  if (updates.narrativeEndIndex !== void 0) {
+    fields.push("narrative_end_index = @narrativeEndIndex");
+    params.narrativeEndIndex = updates.narrativeEndIndex;
+  }
+  if (updates.batchId !== void 0) {
+    fields.push("batch_id = @batchId");
+    params.batchId = updates.batchId;
+  }
+  if (updates.batchFileId !== void 0) {
+    fields.push("batch_file_id = @batchFileId");
+    params.batchFileId = updates.batchFileId;
+  }
+  if (updates.batchChunks !== void 0) {
+    fields.push("batch_chunks = @batchChunks");
+    params.batchChunks = updates.batchChunks;
+  }
+  if (updates.ingestState !== void 0) {
+    fields.push("ingest_state = @ingestState");
+    params.ingestState = updates.ingestState;
+  }
+  if (updates.ingestResumePath !== void 0) {
+    fields.push("ingest_resume_path = @ingestResumePath");
+    params.ingestResumePath = updates.ingestResumePath;
+  }
+  if (fields.length === 0) return;
+  const db = await getDb();
+  db.prepare(`UPDATE books SET ${fields.join(", ")} WHERE id = @id`).run(params);
+};
+var getBooks = async () => {
+  const db = await getDb();
+  const rows = db.prepare("SELECT * FROM books ORDER BY created_at DESC").all();
+  return rows.map(mapRow);
+};
+var getBook = async (id) => {
+  const db = await getDb();
+  const row = db.prepare("SELECT * FROM books WHERE id = ?").get(id);
+  return row ? mapRow(row) : null;
+};
+var getBookBatchChunks = async (id) => {
+  const db = await getDb();
+  const row = db.prepare("SELECT batch_chunks FROM books WHERE id = ?").get(id);
+  return row?.batch_chunks ?? null;
+};
+var deleteBook = async (id) => {
+  const db = await getDb();
+  db.prepare("DELETE FROM chat_messages WHERE session_id IN (SELECT id FROM chat_sessions WHERE book_id = ?)").run(id);
+  db.prepare("DELETE FROM chat_sessions WHERE book_id = ?").run(id);
+  db.prepare("DELETE FROM books WHERE id = ?").run(id);
+};
+var mapSession = (row) => ({
+  id: row.id,
+  bookId: row.book_id,
+  title: row.title ?? null,
+  summary: row.summary ?? null,
+  createdAt: row.created_at ?? 0,
+  updatedAt: row.updated_at ?? 0
+});
+var mapSessionSummary = (row) => ({
+  ...mapSession(row),
+  bookTitle: row.book_title ?? null
+});
+var mapMessage = (row) => ({
+  id: row.id,
+  sessionId: row.session_id,
+  role: row.role,
+  content: row.content,
+  tokenCount: row.token_count ?? null,
+  createdAt: row.created_at ?? 0
+});
+var insertChatSession = async (session) => {
+  const db = await getDb();
+  db.prepare(
+    "INSERT INTO chat_sessions (id, book_id, title, summary, created_at, updated_at) VALUES (@id, @bookId, @title, @summary, @createdAt, @updatedAt)"
+  ).run({
+    id: session.id,
+    bookId: session.bookId,
+    title: session.title ?? null,
+    summary: session.summary ?? null,
+    createdAt: session.createdAt ?? Date.now(),
+    updatedAt: session.updatedAt ?? Date.now()
+  });
+  return session.id;
+};
+var updateChatSession = async (id, updates) => {
+  const fields = [];
+  const params = { id };
+  if (updates.title !== void 0) {
+    fields.push("title = @title");
+    params.title = updates.title;
+  }
+  if (updates.summary !== void 0) {
+    fields.push("summary = @summary");
+    params.summary = updates.summary;
+  }
+  if (updates.updatedAt !== void 0) {
+    fields.push("updated_at = @updatedAt");
+    params.updatedAt = updates.updatedAt;
+  }
+  if (fields.length === 0) return;
+  const db = await getDb();
+  db.prepare(`UPDATE chat_sessions SET ${fields.join(", ")} WHERE id = @id`).run(params);
+};
+var getChatSession = async (id) => {
+  const db = await getDb();
+  const row = db.prepare("SELECT * FROM chat_sessions WHERE id = ?").get(id);
+  return row ? mapSession(row) : null;
+};
+var listChatSessions = async () => {
+  const db = await getDb();
+  const rows = db.prepare(
+    "SELECT chat_sessions.*, books.title as book_title FROM chat_sessions LEFT JOIN books ON books.id = chat_sessions.book_id ORDER BY chat_sessions.updated_at DESC"
+  ).all();
+  return rows.map(mapSessionSummary);
+};
+var insertChatMessage = async (message) => {
+  const db = await getDb();
+  db.prepare(
+    "INSERT INTO chat_messages (id, session_id, role, content, token_count, created_at) VALUES (@id, @sessionId, @role, @content, @tokenCount, @createdAt)"
+  ).run({
+    id: message.id,
+    sessionId: message.sessionId,
+    role: message.role,
+    content: message.content,
+    tokenCount: message.tokenCount ?? null,
+    createdAt: message.createdAt ?? Date.now()
+  });
+  return message.id;
+};
+var getChatMessages = async (sessionId, limit) => {
+  const db = await getDb();
+  const rows = limit !== void 0 ? db.prepare("SELECT * FROM chat_messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ?").all(sessionId, limit) : db.prepare("SELECT * FROM chat_messages WHERE session_id = ? ORDER BY created_at ASC").all(sessionId);
+  const mapped = rows.map(mapMessage);
+  return limit !== void 0 ? mapped.reverse() : mapped;
+};
+
+// src/services/ingest.ts
+var resumePathForBook = async (bookId) => {
+  const paths = await ensureDataDirs();
+  return `${paths.ingestDir}/${bookId}.json`;
+};
+var loadResumeState = async (bookId, resumePath) => {
+  const raw = await readFile(resumePath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed.chunks) || typeof parsed.resumeIndex !== "number") {
+    throw new Error(`Invalid resume state for book ${bookId}. Re-ingest to start over.`);
+  }
+  return parsed;
+};
+var persistResumeState = async (bookId, state) => {
+  const resumePath = await resumePathForBook(bookId);
+  await writeFile(resumePath, JSON.stringify(state));
+  await updateBook(bookId, {
+    ingestState: "pending",
+    ingestResumePath: resumePath
+  });
+  return resumePath;
+};
+var finalizeResumeState = async (bookId, resumePath) => {
+  const path = resumePath || await resumePathForBook(bookId);
+  await unlink(path).catch(() => void 0);
+  await updateBook(bookId, { ingestState: null, ingestResumePath: null });
+};
+var formatDuration = (ms) => {
+  const seconds = Math.round(ms / 100) / 10;
+  return `${seconds}s`;
+};
+var ingestEpub = async (filePath, selectedChapterIndices, options) => {
+  const bookId = randomUUID();
+  const paths = await ensureDataDirs();
+  const fileName = `${bookId}.epub`;
+  const bookPath = `${paths.booksDir}/${fileName}`;
+  let resumePath = null;
+  logInfo(`[Ingest] Starting ingestion for book ${bookId}`);
+  await mkdir(paths.booksDir, { recursive: true });
+  await copyFile(filePath, bookPath);
+  logInfo(`[Ingest] EPUB file saved to ${bookPath}`);
+  const parseStart = Date.now();
+  const parsed = await parseEpub(bookPath);
+  logInfo(`[Ingest] Parsed "${parsed.title}" with ${parsed.chapters.length} chapters (${formatDuration(Date.now() - parseStart)})`);
+  logInfo(`[Ingest] Narrative chapters: ${parsed.narrativeStartIndex} to ${parsed.narrativeEndIndex}`);
+  await insertBook({
+    id: bookId,
+    title: parsed.title,
+    author: parsed.author,
+    coverPath: parsed.coverImagePath,
+    epubPath: bookPath,
+    chapters: parsed.chapterTitles,
+    narrativeStartIndex: parsed.narrativeStartIndex,
+    narrativeEndIndex: parsed.narrativeEndIndex
+  });
+  logInfo(`[Ingest] Book record inserted into database`);
+  try {
+    const chaptersToProcess = selectedChapterIndices ? parsed.chapters.filter((_, index) => selectedChapterIndices.includes(index)) : parsed.chapters.slice(parsed.narrativeStartIndex, parsed.narrativeEndIndex + 1);
+    const selectedIndices = selectedChapterIndices || Array.from(
+      { length: parsed.narrativeEndIndex - parsed.narrativeStartIndex + 1 },
+      (_, i) => i + parsed.narrativeStartIndex
+    );
+    logInfo(`[Ingest] Processing ${chaptersToProcess.length} selected chapters (indices: ${selectedIndices.join(", ")})`);
+    let adjustedSummaries = [];
+    if (options?.summarize !== false) {
+      logInfo(`[Ingest] Generating summaries for ${chaptersToProcess.length} chapters...`);
+      const summarizeStart = Date.now();
+      const summaries = await summarizeAllChapters(chaptersToProcess, { batch: options?.batch });
+      logInfo(`[Ingest] Generated ${summaries.length}/${chaptersToProcess.length} summaries (${formatDuration(Date.now() - summarizeStart)})`);
+      const summaryRecords = summaries.map((s, idx) => ({
+        ...s,
+        chapterIndex: selectedIndices[idx] ?? s.chapterIndex
+      }));
+      await updateBook(bookId, {
+        summaries: JSON.stringify(summaryRecords)
+      });
+      adjustedSummaries = summaryRecords.map((s) => ({
+        id: `${bookId}-summary-${s.chapterIndex}`,
+        bookId,
+        chapterIndex: s.chapterIndex,
+        chapterTitle: s.chapterTitle,
+        chunkIndex: -1,
+        content: s.fullSummary,
+        type: "summary"
+      }));
+      logInfo(`[Ingest] Created ${adjustedSummaries.length} summary chunks`);
+    }
+    const chunksToProcess = parsed.chapters.map(
+      (chapter, index) => selectedIndices.includes(index) ? chapter : { title: chapter.title, content: "" }
+    );
+    const chunks = chunkChapters(bookId, chunksToProcess).filter((chunk) => chunk.content.length > 0);
+    logInfo(`[Ingest] Created ${chunks.length} chunks from selected chapters`);
+    const allChunks = [...chunks, ...adjustedSummaries];
+    if (options?.batch) {
+      logInfo(`[Ingest] Submitting ${allChunks.length} chunks to OpenAI Batch API`);
+      const { batchId, inputFileId } = await submitBatchEmbeddings(allChunks);
+      await updateBook(bookId, {
+        batchId,
+        batchFileId: inputFileId,
+        batchChunks: JSON.stringify(allChunks)
+      });
+      logInfo(`[Ingest] Batch submitted (${batchId}). Run "mycroft book ingest resume ${bookId.slice(0, 8)}" to complete ingestion.`);
+    } else {
+      const embedStart = Date.now();
+      resumePath = await persistResumeState(bookId, { chunks: allChunks, resumeIndex: 0 });
+      const embedded = await embedChunks(allChunks, {
+        onBatch: async (embeddedBatch, progress) => {
+          await addChunksToIndex(bookId, embeddedBatch);
+          await updateBook(bookId, { chunkCount: progress.completed });
+          if (!resumePath) return;
+          await writeFile(
+            resumePath,
+            JSON.stringify({ chunks: allChunks, resumeIndex: progress.completed })
+          );
+        }
+      });
+      logInfo(`[Ingest] Embedded ${embedded.length} total chunks (${formatDuration(Date.now() - embedStart)})`);
+      await updateBook(bookId, { chunkCount: embedded.length, indexedAt: Date.now() });
+      logInfo(`[Ingest] Updated book record with chunk count: ${embedded.length}`);
+      await finalizeResumeState(bookId, resumePath);
+    }
+  } catch (error) {
+    logWarn(`[Ingest] Error during chunking/embedding: ${error instanceof Error ? error.message : String(error)}`);
+    if (resumePath) {
+      logWarn(`[Ingest] Partial progress saved. Run "mycroft book ingest resume ${bookId.slice(0, 8)}" to continue.`);
+      return { id: bookId, status: "interrupted" };
+    } else {
+      await deleteBookIndex(bookId);
+      await unlink(bookPath).catch(() => void 0);
+      await deleteBook(bookId).catch(() => void 0);
+    }
+    throw error;
+  }
+  logInfo(`[Ingest] Ingestion complete for ${bookId}`);
+  return { id: bookId, status: "completed" };
+};
+var resumeIngest = async (bookId, storedChunks, batchId, batchFileId) => {
+  const { checkBatchStatus, downloadBatchResults, cleanupBatchFiles } = await import("./batch-embedder-IZDBS3IL.js");
+  logInfo(`[Resume] Checking batch ${batchId} for book ${bookId}`);
+  const status = await checkBatchStatus(batchId);
+  logInfo(`[Resume] Batch status: ${status.status} (completed: ${status.completed}/${status.total})`);
+  if (["validating", "in_progress", "finalizing"].includes(status.status)) {
+    return { status: status.status, completed: status.completed, total: status.total };
+  }
+  if (status.status === "failed" || status.status === "expired" || status.status === "cancelled") {
+    logWarn(`[Resume] Batch ${batchId} ended with status "${status.status}". Re-submitting...`);
+    await cleanupBatchFiles(batchFileId, status.outputFileId);
+    const { submitBatchEmbeddings: submitBatchEmbeddings2 } = await import("./batch-embedder-IZDBS3IL.js");
+    const { batchId: newBatchId, inputFileId: newFileId } = await submitBatchEmbeddings2(storedChunks);
+    await updateBook(bookId, { batchId: newBatchId, batchFileId: newFileId });
+    logInfo(`[Resume] New batch submitted (${newBatchId}). Run resume again later.`);
+    return { status: "resubmitted", batchId: newBatchId };
+  }
+  if (status.status !== "completed" || !status.outputFileId) {
+    throw new Error(`Unexpected batch status: ${status.status}`);
+  }
+  const embedded = await downloadBatchResults(status.outputFileId, storedChunks);
+  await addChunksToIndex(bookId, embedded);
+  logInfo(`[Resume] Added ${embedded.length} chunks to vector index`);
+  await updateBook(bookId, {
+    chunkCount: embedded.length,
+    indexedAt: Date.now(),
+    batchId: null,
+    batchFileId: null,
+    batchChunks: null
+  });
+  logInfo(`[Resume] Book ${bookId} indexing complete`);
+  await cleanupBatchFiles(batchFileId, status.outputFileId);
+  return { status: "completed" };
+};
+var resumeLocalIngest = async (bookId, resumePath, currentChunkCount) => {
+  const state = await loadResumeState(bookId, resumePath);
+  const total = state.chunks.length;
+  const startIndex = Math.max(state.resumeIndex, currentChunkCount);
+  if (startIndex >= total) {
+    await finalizeResumeState(bookId, resumePath);
+    throw new Error(`Resume state already completed for book ${bookId}.`);
+  }
+  logInfo(`[Resume] Resuming local embeddings at chunk ${startIndex + 1}/${total}`);
+  const embedStart = Date.now();
+  const remaining = state.chunks.slice(startIndex);
+  const embeddedRemaining = await embedChunks(remaining, {
+    onBatch: async (embeddedBatch, progress) => {
+      const completed = startIndex + progress.completed;
+      await addChunksToIndex(bookId, embeddedBatch);
+      await updateBook(bookId, { chunkCount: completed });
+      await writeFile(
+        resumePath,
+        JSON.stringify({ chunks: state.chunks, resumeIndex: completed })
+      );
+    }
+  });
+  logInfo(`[Resume] Embedded ${embeddedRemaining.length} remaining chunks (${formatDuration(Date.now() - embedStart)})`);
+  const finalCount = startIndex + embeddedRemaining.length;
+  await updateBook(bookId, {
+    chunkCount: finalCount,
+    indexedAt: Date.now()
+  });
+  await finalizeResumeState(bookId, resumePath);
+  return { status: "completed", chunkCount: finalCount };
+};
+
+// src/commands/ingest.ts
+import { access } from "fs/promises";
+
+// src/commands/prompt.ts
+import { createInterface } from "readline/promises";
+var prompt = async (question) => {
+  const release = handleSigint();
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const response = await rl.question(question);
+    return response.trim();
+  } finally {
+    rl.close();
+    release();
+  }
+};
+var confirm = async (question) => {
+  const response = await prompt(question);
+  const normalized = response.trim().toLowerCase();
+  return normalized === "y" || normalized === "yes";
+};
+
+// src/commands/ingest.ts
+var parseIndexSelection = (input, max) => {
+  const trimmed = input.trim();
+  if (!trimmed) return [];
+  const tokens = trimmed.split(",").map((part) => part.trim()).filter(Boolean);
+  const indices = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    if (token.includes("-")) {
+      const [startRaw, endRaw] = token.split("-");
+      const start = Number(startRaw);
+      const end = Number(endRaw);
+      if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+      for (let i = Math.min(start, end); i <= Math.max(start, end); i++) {
+        if (i >= 0 && i < max) indices.add(i);
+      }
+    } else {
+      const index = Number(token);
+      if (Number.isFinite(index) && index >= 0 && index < max) indices.add(index);
+    }
+  }
+  return Array.from(indices).sort((a, b) => a - b);
+};
+var ingestCommand = async (filePath, options) => {
+  requireOpenAIKey();
+  await ensureDataDirs();
+  try {
+    await access(filePath);
+  } catch {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  let selectedChapterIndices;
+  if (options.manual) {
+    if (!isInteractive()) {
+      throw new Error("Manual chapter selection requires an interactive terminal.");
+    }
+    const parsed = await parseEpub(filePath);
+    if (parsed.chapterTitles.length === 0) {
+      throw new Error("No chapters found in EPUB");
+    }
+    stdout("Chapters:");
+    parsed.chapterTitles.forEach((title, index) => {
+      const marker = index >= parsed.narrativeStartIndex && index <= parsed.narrativeEndIndex ? "*" : " ";
+      stdout(`${marker} [${index}] ${title}`);
+    });
+    stdout("\nEnter chapter indices to ingest (e.g. 0-10,12). Press Enter for narrative range.");
+    const answer = await prompt("Selection: ");
+    const indices = parseIndexSelection(answer, parsed.chapterTitles.length);
+    if (indices.length > 0) {
+      selectedChapterIndices = indices;
+    } else {
+      selectedChapterIndices = Array.from(
+        { length: parsed.narrativeEndIndex - parsed.narrativeStartIndex + 1 },
+        (_, i) => i + parsed.narrativeStartIndex
+      );
+    }
+  }
+  const result = await ingestEpub(filePath, selectedChapterIndices, { summarize: options.summarize ?? false, batch: options.batch ?? false });
+  if (result.status === "interrupted") {
+    stdout(`
+Ingest interrupted. Run "mycroft book ingest resume ${result.id.slice(0, 8)}" to continue.`);
+    return;
+  }
+  if (options.batch) {
+    stdout(`
+Batch submitted. Book registered as ${result.id}`);
+    stdout(`Use "mycroft book ingest resume ${result.id.slice(0, 8)}" to complete ingestion once the batch finishes.`);
+  } else {
+    stdout(`
+Done. Book indexed as ${result.id}`);
+  }
+};
+
+// src/commands/book/ingest.ts
+var registerBookIngest = (program2) => {
+  const ingest = program2.command("ingest").description("Ingest an EPUB file").argument("<path>", "Path to the EPUB file").option("--manual", "Interactive chapter selection").option("--summary", "Enable AI chapter summaries").option("--batch", "Use OpenAI Batch API for embeddings (50% cost savings, up to 24h)").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book ingest ./book.epub
+  mycroft book ingest ./book.epub --summary
+  mycroft book ingest ./book.epub --batch
+  mycroft book ingest resume 8f2c1a4b
+
+NOTES
+  --batch submits embeddings and returns immediately.
+  Use "mycroft book ingest resume <id>" after the batch completes to finish indexing.
+  Non-batch ingests can also be resumed if interrupted.
+`
+  ).action(async (path, options) => {
+    const summarize = Boolean(options.summary);
+    await ingestCommand(path, { manual: options.manual, summarize, batch: options.batch });
+  });
+  return ingest;
+};
+
+// src/commands/list.ts
+var formatDate = (timestamp) => {
+  if (!timestamp) return "-";
+  return new Date(timestamp).toISOString().slice(0, 10);
+};
+var listCommand = async () => {
+  await ensureDataDirs();
+  const books = await getBooks();
+  if (books.length === 0) {
+    stdout("No books indexed yet.");
+    return;
+  }
+  stdout("ID       | Title | Author | Chunks | Indexed | Status");
+  stdout("---------|-------|--------|--------|--------|-------");
+  for (const book of books) {
+    const shortId = book.id.slice(0, 8);
+    const title = book.title;
+    const author = book.author || "-";
+    const chunks = String(book.chunkCount ?? 0);
+    const indexed = formatDate(book.indexedAt);
+    const status = book.indexedAt ? "[indexed]" : book.batchId ? "[batch pending]" : book.ingestState === "pending" ? "[resume pending]" : "[pending]";
+    stdout(`${shortId} | ${title} | ${author} | ${chunks} | ${indexed} | ${status}`);
+  }
+};
+
+// src/commands/book/list.ts
+var registerBookList = (program2) => {
+  program2.command("list").description("List indexed books").action(async () => {
+    await listCommand();
+  });
+};
+
+// src/commands/utils.ts
+var resolveBookId = async (input) => {
+  const books = await getBooks();
+  const exact = books.find((book) => book.id === input);
+  if (exact) return exact.id;
+  const matches = books.filter((book) => book.id.startsWith(input));
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous id prefix "${input}" (${matches.length} matches)`);
+  }
+  return null;
+};
+
+// src/commands/show.ts
+var showCommand = async (id) => {
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(id);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const book = await getBook(resolvedId);
+  if (!book) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  stdout(`Title: ${book.title}`);
+  stdout(`Author: ${book.author ?? "-"}`);
+  stdout(`ID: ${book.id}`);
+  stdout(`Chunks: ${book.chunkCount}`);
+  stdout(`Indexed: ${book.indexedAt ? new Date(book.indexedAt).toISOString() : "-"}`);
+  stdout(`Narrative range: ${book.narrativeStartIndex ?? 0} to ${book.narrativeEndIndex ?? book.chapters.length - 1}`);
+  stdout(`Progress chapter: ${book.progressChapter ?? "-"}`);
+  stdout(`Ingest status: ${book.ingestState ?? "-"}`);
+  stdout("\nChapters:");
+  book.chapters.forEach((title, index) => {
+    const marker = index === book.narrativeStartIndex ? "[start]" : index === book.narrativeEndIndex ? "[end]" : "";
+    stdout(`  [${index}] ${title} ${marker}`.trim());
+  });
+};
+
+// src/commands/book/show.ts
+var registerBookShow = (program2) => {
+  program2.command("show").description("Show full book metadata").argument("<id>", "Book id or prefix").action(async (id) => {
+    await showCommand(id);
+  });
+};
+
+// src/commands/ask.ts
+import { embed, streamText } from "ai";
+import { openai as openai3 } from "@ai-sdk/openai";
+var formatContext = (chunks) => chunks.map(
+  (chunk, index) => `Excerpt [${index + 1}] (${chunk.chapterTitle || `Chapter ${chunk.chapterIndex + 1}`}):
+${chunk.content}`
+).join("\n\n");
+var askCommand = async (id, question, options) => {
+  if (!await isAskEnabled()) {
+    throw new Error("Ask is disabled in config (askEnabled: false). Enable it to use this command.");
+  }
+  requireOpenAIKey();
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(id);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const book = await getBook(resolvedId);
+  if (!book) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const models = await getModels();
+  const { embedding } = await embed({
+    model: openai3.embeddingModel(models.embedding),
+    value: question
+  });
+  const narrativeStart = book.narrativeStartIndex ?? 0;
+  const userProgress = book.progressChapter ?? null;
+  const maxChapterIndex = options.maxChapter !== void 0 ? narrativeStart + options.maxChapter : userProgress !== null ? narrativeStart + userProgress : void 0;
+  const retrievalLimit = options.topK * 3;
+  const allMatches = await queryBookIndex(resolvedId, embedding, question, retrievalLimit, maxChapterIndex);
+  const summaries = allMatches.filter((m) => m.type === "summary");
+  const chunks = allMatches.filter((m) => m.type !== "summary");
+  const topSummaries = summaries.slice(0, 2);
+  const topChunks = chunks.slice(0, Math.max(0, options.topK - topSummaries.length));
+  const selectedMatches = [...topSummaries, ...topChunks];
+  const context = formatContext(selectedMatches);
+  const releaseSigint = handleSigint();
+  const stream = streamText({
+    model: openai3(models.chat),
+    system: `You are a reading companion helping readers understand this book.
+
+Guidelines:
+- Use the provided chapter summaries and excerpts to answer questions
+- Chapter summaries provide high-level context about characters, events, and plot
+- Excerpts provide specific details and quotes
+- When asked for recaps or "what happened", synthesize from summaries
+- Don't cite table of contents, front matter, or structural elements
+- If truly unsure, briefly say so - but try to answer from available context first
+- Cite sources using [1], [2], etc. at the end of relevant sentences
+- The context may be limited to earlier chapters only - don't infer beyond what's provided`,
+    prompt: `Question: ${question}
+
+${context}`
+  });
+  try {
+    for await (const part of stream.textStream) {
+      process.stdout.write(part);
+    }
+  } finally {
+    releaseSigint();
+  }
+  if (selectedMatches.length > 0) {
+    process.stdout.write("\n\nSources:\n");
+    selectedMatches.forEach((match, index) => {
+      const title = match.chapterTitle || `Chapter ${match.chapterIndex + 1}`;
+      const excerpt = match.content.slice(0, 120).replace(/\s+/g, " ");
+      process.stdout.write(`[${index + 1}] ${title}: ${excerpt}
+`);
+    });
+  }
+};
+
+// src/commands/query-options.ts
+var parseQueryOptions = (options) => {
+  const topK = Number(options.topK);
+  if (!Number.isFinite(topK) || topK <= 0) {
+    throw new Error("--top-k must be a positive number.");
+  }
+  let maxChapter;
+  if (options.maxChapter !== void 0) {
+    const parsed = Number(options.maxChapter);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+      throw new Error("--max-chapter must be a non-negative number.");
+    }
+    maxChapter = parsed;
+  }
+  return { topK, maxChapter };
+};
+
+// src/commands/book/ask.ts
+var registerBookAsk = (program2) => {
+  program2.command("ask").description("Ask a question about a book").argument("<id>", "Book id or prefix").argument("<question>", "Question to ask").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (id, question, options) => {
+    const { topK, maxChapter } = parseQueryOptions(options);
+    await askCommand(id, question, { topK, maxChapter });
+  });
+};
+
+// src/commands/search.ts
+import { embed as embed2 } from "ai";
+import { openai as openai4 } from "@ai-sdk/openai";
+var searchCommand = async (id, query, options) => {
+  requireOpenAIKey();
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(id);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const book = await getBook(resolvedId);
+  if (!book) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const models = await getModels();
+  const { embedding } = await embed2({
+    model: openai4.embeddingModel(models.embedding),
+    value: query
+  });
+  const maxChapterIndex = options.maxChapter !== void 0 ? (book.narrativeStartIndex ?? 0) + options.maxChapter : book.progressChapter !== null ? (book.narrativeStartIndex ?? 0) + (book.progressChapter ?? 0) : void 0;
+  const results = await queryBookIndex(resolvedId, embedding, query, options.topK, maxChapterIndex);
+  if (results.length === 0) {
+    stdout("No results.");
+    return;
+  }
+  results.forEach((result, index) => {
+    const chapterTitle = result.chapterTitle || `Chapter ${result.chapterIndex + 1}`;
+    const excerpt = result.content.slice(0, 200).replace(/\s+/g, " ");
+    stdout(`
+#${index + 1} score=${result.score.toFixed(4)} type=${result.type || "chunk"}`);
+    stdout(`${chapterTitle} (chapter ${result.chapterIndex})`);
+    stdout(excerpt);
+  });
+};
+
+// src/commands/book/search.ts
+var registerBookSearch = (program2) => {
+  program2.command("search").description("Vector search without LLM").argument("<id>", "Book id or prefix").argument("<query>", "Search query").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (id, query, options) => {
+    const { topK, maxChapter } = parseQueryOptions(options);
+    await searchCommand(id, query, { topK, maxChapter });
+  });
+};
+
+// src/commands/delete.ts
+import { unlink as unlink2 } from "fs/promises";
+var deleteCommand = async (id, options) => {
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(id);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const book = await getBook(resolvedId);
+  if (!book) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  if (!options.force) {
+    if (!isInteractive()) {
+      throw new Error("Delete confirmation requires an interactive terminal. Use --force to bypass.");
+    }
+    const ok = await confirm(`Delete "${book.title}" (${book.id})? [y/N] `);
+    if (!ok) {
+      stdout("Cancelled.");
+      return;
+    }
+  }
+  await deleteBook(resolvedId);
+  await deleteBookIndex(resolvedId);
+  if (book.epubPath) {
+    await unlink2(book.epubPath).catch(() => void 0);
+  }
+  stdout(`Deleted book ${book.id}`);
+};
+
+// src/commands/book/delete.ts
+var registerBookDelete = (program2) => {
+  program2.command("delete").description("Remove book, EPUB, and vectors").argument("<id>", "Book id or prefix").option("--force", "Skip confirmation").action(async (id, options) => {
+    await deleteCommand(id, { force: options.force });
+  });
+};
+
+// src/commands/resume.ts
+var resumeCommand = async (id) => {
+  requireOpenAIKey();
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(id);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  const book = await getBook(resolvedId);
+  if (!book) {
+    throw new Error(`Book not found: ${id}`);
+  }
+  if (book.indexedAt) {
+    stdout(`Book "${book.title}" is already indexed (${book.chunkCount} chunks).`);
+    return;
+  }
+  if (book.batchId) {
+    const rawChunks = await getBookBatchChunks(resolvedId);
+    if (!rawChunks) {
+      throw new Error(`No stored chunks found for book "${book.title}". Re-ingest with "mycroft book ingest --batch".`);
+    }
+    const chunks = JSON.parse(rawChunks);
+    const result2 = await resumeIngest(resolvedId, chunks, book.batchId, book.batchFileId ?? book.batchId);
+    if (result2.status === "completed") {
+      stdout(`
+Done. Book "${book.title}" indexed as ${book.id}`);
+    } else if (result2.status === "resubmitted") {
+      stdout(`
+Batch failed and was re-submitted (${result2.batchId}). Run resume again later.`);
+    } else {
+      stdout(`
+Batch still in progress (${result2.status}: ${result2.completed}/${result2.total}). Run resume again later.`);
+    }
+    return;
+  }
+  if (!book.ingestResumePath || book.ingestState !== "pending") {
+    throw new Error(`Book "${book.title}" has no resumable ingest. Re-ingest to start one.`);
+  }
+  const result = await resumeLocalIngest(resolvedId, book.ingestResumePath, book.chunkCount ?? 0);
+  if (result.status === "completed") {
+    stdout(`
+Done. Book "${book.title}" indexed as ${book.id}`);
+  }
+};
+
+// src/commands/book/resume.ts
+var registerBookResume = (program2, ingest) => {
+  const target = ingest ?? program2.command("ingest");
+  target.command("resume").description("Resume a pending ingestion").argument("<id>", "Book id or prefix").addHelpText(
+    "after",
+    `
+EXAMPLES
+  mycroft book ingest resume 8f2c1a4b
+
+NOTES
+  Resumes either batch or non-batch ingests if interrupted.
+`
+  ).action(async (id) => {
+    await resumeCommand(id);
+  });
+};
+
+// src/commands/config.ts
+var configCommand = async () => {
+  const path = configPath();
+  stdout(path);
+};
+
+// src/commands/config/path.ts
+var registerConfigPath = (program2) => {
+  program2.command("path").description("Print config path").action(async () => {
+    await configCommand();
+  });
+};
+
+// src/commands/init-config.ts
+import { mkdir as mkdir2, writeFile as writeFile2, access as access2 } from "fs/promises";
+var initConfigCommand = async () => {
+  const path = configPath();
+  await ensureConfigDirs(path);
+  try {
+    await access2(path);
+    stdout(`Config already exists: ${path}`);
+    return;
+  } catch {
+  }
+  const resolved = await loadConfig();
+  const template = {
+    dataDir: "~/.local/share/mycroft",
+    askEnabled: resolved.askEnabled,
+    models: resolved.models
+  };
+  await writeFile2(path, JSON.stringify(template, null, 2), "utf-8");
+  await mkdir2(resolved.dataDir, { recursive: true });
+  stdout(`Created config at ${path}`);
+};
+
+// src/commands/config/init.ts
+var registerConfigInit = (program2) => {
+  program2.command("init").description("Create default config file").action(async () => {
+    await initConfigCommand();
+  });
+};
+
+// src/commands/resolve-config.ts
+var resolveConfigCommand = async () => {
+  const path = configPath();
+  const config = await loadConfig();
+  stdout(`Config: ${path}`);
+  stdout(`Data dir: ${config.dataDir}`);
+  stdout(`Ask enabled: ${config.askEnabled}`);
+  stdout(`Models: embedding=${config.models.embedding} summary=${config.models.summary} chat=${config.models.chat}`);
+};
+
+// src/commands/config/resolve.ts
+var registerConfigResolve = (program2) => {
+  program2.command("resolve").description("Print resolved config values").action(async () => {
+    await resolveConfigCommand();
+  });
+};
+
+// src/commands/onboard.ts
+import { writeFile as writeFile3 } from "fs/promises";
+var isDefault = (input) => input === "" || input.toLowerCase() === "-y";
+var parseBoolean = (input, fallback) => {
+  if (isDefault(input)) return fallback;
+  const normalized = input.toLowerCase();
+  if (["y", "yes", "true", "1"].includes(normalized)) return true;
+  if (["n", "no", "false", "0"].includes(normalized)) return false;
+  return fallback;
+};
+var onboardCommand = async () => {
+  if (!isInteractive()) {
+    throw new Error("Onboarding requires an interactive terminal.");
+  }
+  const defaults = await loadConfig();
+  const path = configPath();
+  stdout("\nmycroft");
+  stdout("Press Enter or type -y to accept defaults.");
+  const dataDirInput = await prompt(`Data directory [${defaults.dataDir}]: `);
+  const dataDir = isDefault(dataDirInput) ? defaults.dataDir : dataDirInput;
+  const askEnabledInput = await prompt(`Enable ask (LLM answers) [${defaults.askEnabled ? "Y" : "N"}]: `);
+  const askEnabled = parseBoolean(askEnabledInput, defaults.askEnabled);
+  const embeddingInput = await prompt(`Embedding model [${defaults.models.embedding}]: `);
+  const embedding = isDefault(embeddingInput) ? defaults.models.embedding : embeddingInput;
+  const summaryInput = await prompt(`Summary model [${defaults.models.summary}]: `);
+  const summary = isDefault(summaryInput) ? defaults.models.summary : summaryInput;
+  const chatInput = await prompt(`Chat model [${defaults.models.chat}]: `);
+  const chat = isDefault(chatInput) ? defaults.models.chat : chatInput;
+  await ensureConfigDirs(path);
+  await writeFile3(
+    path,
+    JSON.stringify(
+      {
+        dataDir,
+        askEnabled,
+        models: {
+          embedding,
+          summary,
+          chat
+        }
+      },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+  stdout("\nSetup complete.");
+  stdout(`Config: ${path}`);
+  stdout(`Data dir: ${dataDir}`);
+  if (!process.env.OPENAI_API_KEY) {
+    stdout("\nOPENAI_API_KEY is not set.");
+    stdout("Export it to enable embeddings and chat:");
+    stdout('  export OPENAI_API_KEY="..."');
+  }
+  stdout("\nNext step:");
+  stdout("  mycroft book ingest /path/to/book.epub");
+};
+
+// src/commands/config/onboard.ts
+var registerConfigOnboard = (program2) => {
+  program2.command("onboard").description("Initialize config and show next step").action(async () => {
+    await onboardCommand();
+  });
+};
+
+// src/services/chat.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { embed as embed3, generateText as generateText2 } from "ai";
+import { openai as openai5 } from "@ai-sdk/openai";
+var MAX_RECENT_MESSAGES = 12;
+var SUMMARY_TRIGGER_MESSAGES = 24;
+var SUMMARY_TARGET_WORDS2 = 160;
+var formatContext2 = (chunks) => chunks.map(
+  (chunk, index) => `Excerpt [${index + 1}] (${chunk.chapterTitle || `Chapter ${chunk.chapterIndex + 1}`}):
+${chunk.content}`
+).join("\n\n");
+var estimateTokens2 = (text) => Math.ceil(text.length / 4);
+var summarizeMessages = async (messages) => {
+  const transcript = messages.map((message) => `${message.role.toUpperCase()}: ${message.content}`).join("\n\n");
+  const models = await getModels();
+  const { text } = await generateText2({
+    model: openai5(models.summary),
+    prompt: `Summarize this conversation so far in ~${SUMMARY_TARGET_WORDS2} words. Focus on facts, decisions, and unresolved questions.
+
+${transcript}`,
+    temperature: 0.3
+  });
+  return text.trim();
+};
+var buildConversationContext = (session, messages) => {
+  const summary = session.summary ? `Conversation summary:
+${session.summary}` : "";
+  const recent = messages.slice(-MAX_RECENT_MESSAGES).map((message) => `${message.role.toUpperCase()}: ${message.content}`).join("\n\n");
+  return [summary, recent].filter(Boolean).join("\n\n");
+};
+var maybeSummarizeSession = async (session, messages, updatedAt) => {
+  if (messages.length < SUMMARY_TRIGGER_MESSAGES) return;
+  const summary = await summarizeMessages(messages.slice(0, -MAX_RECENT_MESSAGES));
+  await updateChatSession(session.id, { summary, updatedAt });
+};
+var listSessions = async () => listChatSessions();
+var getSession = async (id) => getChatSession(id);
+var getSessionMessages = async (sessionId, limit) => getChatMessages(sessionId, limit);
+var startSession = async (bookId, title) => {
+  await ensureDataDirs();
+  const resolvedId = await resolveBookId(bookId);
+  if (!resolvedId) {
+    throw new Error(`Book not found: ${bookId}`);
+  }
+  const sessionId = randomUUID2();
+  await insertChatSession({
+    id: sessionId,
+    bookId: resolvedId,
+    title: title ?? null,
+    summary: null
+  });
+  const session = await getChatSession(sessionId);
+  if (!session) {
+    throw new Error("Failed to create chat session.");
+  }
+  return session;
+};
+var chatAsk = async (sessionId, question, options) => {
+  if (!await isAskEnabled()) {
+    throw new Error("Ask is disabled in config (askEnabled: false). Enable it to use this command.");
+  }
+  requireOpenAIKey();
+  await ensureDataDirs();
+  const session = await getChatSession(sessionId);
+  if (!session) {
+    throw new Error(`Chat session not found: ${sessionId}`);
+  }
+  const book = await getBook(session.bookId);
+  if (!book) {
+    throw new Error(`Book not found: ${session.bookId}`);
+  }
+  const models = await getModels();
+  const { embedding } = await embed3({
+    model: openai5.embeddingModel(models.embedding),
+    value: question
+  });
+  const narrativeStart = book.narrativeStartIndex ?? 0;
+  const userProgress = book.progressChapter ?? null;
+  const maxChapterIndex = options.maxChapter !== void 0 ? narrativeStart + options.maxChapter : userProgress !== null ? narrativeStart + userProgress : void 0;
+  const retrievalLimit = options.topK * 3;
+  const allMatches = await queryBookIndex(session.bookId, embedding, question, retrievalLimit, maxChapterIndex);
+  const summaries = allMatches.filter((m) => m.type === "summary");
+  const chunks = allMatches.filter((m) => m.type !== "summary");
+  const topSummaries = summaries.slice(0, 2);
+  const topChunks = chunks.slice(0, Math.max(0, options.topK - topSummaries.length));
+  const selectedMatches = [...topSummaries, ...topChunks];
+  const context = formatContext2(selectedMatches);
+  const messages = await getChatMessages(sessionId);
+  const conversation = buildConversationContext(session, messages);
+  const now = Date.now();
+  const userMessage = {
+    id: randomUUID2(),
+    sessionId,
+    role: "user",
+    content: question,
+    tokenCount: estimateTokens2(question),
+    createdAt: now
+  };
+  await insertChatMessage(userMessage);
+  const prompt2 = [
+    conversation ? `Conversation:
+${conversation}` : "",
+    `Question: ${question}`,
+    context
+  ].filter(Boolean).join("\n\n");
+  const { text } = await generateText2({
+    model: openai5(models.chat),
+    system: `You are a reading companion helping readers understand this book.
+
+Guidelines:
+- Use the provided chapter summaries and excerpts to answer questions
+- Chapter summaries provide high-level context about characters, events, and plot
+- Excerpts provide specific details and quotes
+- When asked for recaps or "what happened", synthesize from summaries
+- Don't cite table of contents, front matter, or structural elements
+- If truly unsure, briefly say so - but try to answer from available context first
+- Cite sources using [1], [2], etc. at the end of relevant sentences
+- The context may be limited to earlier chapters only - don't infer beyond what's provided`,
+    prompt: prompt2
+  });
+  const assistantMessage = {
+    id: randomUUID2(),
+    sessionId,
+    role: "assistant",
+    content: text,
+    tokenCount: estimateTokens2(text),
+    createdAt: now
+  };
+  await insertChatMessage(assistantMessage);
+  const updatedAt = Date.now();
+  await updateChatSession(sessionId, { updatedAt });
+  await maybeSummarizeSession(session, [...messages, userMessage, assistantMessage], updatedAt);
+  return { answer: text, sources: selectedMatches };
+};
+
+// src/commands/chat/start.ts
+var registerChatStart = (program2) => {
+  program2.command("start").description("Start a chat session for a book").argument("<id>", "Book id or prefix").option("--title <title>", "Session title").action(async (id, options) => {
+    const session = await startSession(id, options.title);
+    stdout(`Started chat session ${session.id} for book ${session.bookId}`);
+  });
+};
+
+// src/commands/chat/utils.ts
+var resolveChatSessionId = async (input) => {
+  const sessions = await listChatSessions();
+  const exact = sessions.find((session) => session.id === input);
+  if (exact) return exact.id;
+  const matches = sessions.filter((session) => session.id.startsWith(input));
+  if (matches.length === 1) return matches[0].id;
+  if (matches.length > 1) {
+    throw new Error(`Ambiguous session id prefix "${input}" (${matches.length} matches)`);
+  }
+  return null;
+};
+
+// src/commands/chat/ask.ts
+var registerChatAsk = (program2) => {
+  program2.command("ask").description("Ask a question in a chat session").argument("<session>", "Chat session id or prefix").argument("<question>", "Question to ask").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (sessionId, question, options) => {
+    const { topK, maxChapter } = parseQueryOptions(options);
+    const resolvedId = await resolveChatSessionId(sessionId);
+    if (!resolvedId) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    const { answer, sources } = await chatAsk(resolvedId, question, { topK, maxChapter });
+    stdout(answer);
+    if (sources.length > 0) {
+      stdout("\nSources:");
+      sources.forEach((match, index) => {
+        const title = match.chapterTitle || `Chapter ${match.chapterIndex + 1}`;
+        const excerpt = match.content.slice(0, 120).replace(/\s+/g, " ");
+        stdout(`[${index + 1}] ${title}: ${excerpt}`);
+      });
+    }
+  });
+};
+
+// src/commands/chat/list.ts
+var formatDate2 = (timestamp) => {
+  if (!timestamp) return "-";
+  return new Date(timestamp).toISOString().slice(0, 10);
+};
+var registerChatList = (program2) => {
+  program2.command("list").description("List chat sessions").action(async () => {
+    const sessions = await listSessions();
+    if (sessions.length === 0) {
+      stdout("No chat sessions yet.");
+      return;
+    }
+    stdout("ID       | Book | Updated | Title");
+    stdout("---------|------|---------|------");
+    for (const session of sessions) {
+      const shortId = session.id.slice(0, 8);
+      const book = session.bookTitle || session.bookId.slice(0, 8);
+      const updated = formatDate2(session.updatedAt);
+      const title = session.title || "-";
+      stdout(`${shortId} | ${book} | ${updated} | ${title}`);
+    }
+  });
+};
+
+// src/commands/chat/show.ts
+var registerChatShow = (program2) => {
+  program2.command("show").description("Show chat session details").argument("<session>", "Chat session id or prefix").option("--tail <n>", "Show last N messages", "10").action(async (sessionId, options) => {
+    const tail = Number(options.tail);
+    if (!Number.isFinite(tail) || tail <= 0) {
+      throw new Error("--tail must be a positive number.");
+    }
+    const resolvedId = await resolveChatSessionId(sessionId);
+    if (!resolvedId) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    const session = await getSession(resolvedId);
+    if (!session) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    stdout(`ID: ${session.id}`);
+    stdout(`Book ID: ${session.bookId}`);
+    stdout(`Title: ${session.title ?? "-"}`);
+    const updated = session.updatedAt ? new Date(session.updatedAt).toISOString() : "-";
+    stdout(`Updated: ${updated}`);
+    const messages = await getSessionMessages(resolvedId, tail);
+    if (messages.length === 0) {
+      stdout("\nNo messages yet.");
+      return;
+    }
+    stdout("\nMessages:");
+    messages.forEach((message) => {
+      stdout(`[${message.role}] ${message.content}`);
+    });
+  });
+};
+
+// src/commands/chat/repl.ts
+var shouldExit = (input) => {
+  const normalized = input.trim().toLowerCase();
+  return normalized === "exit" || normalized === "quit" || normalized === ":q";
+};
+var registerChatRepl = (program2) => {
+  program2.command("repl").description("Start interactive chat session").argument("<session>", "Chat session id or prefix").option("--top-k <n>", "Number of passages to retrieve", "5").option("--max-chapter <n>", "Spoiler-free limit (0-based within narrative)").action(async (sessionId, options) => {
+    if (!isInteractive()) {
+      throw new Error("Chat repl requires an interactive terminal.");
+    }
+    const { topK, maxChapter } = parseQueryOptions(options);
+    const resolvedId = await resolveChatSessionId(sessionId);
+    if (!resolvedId) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    const session = await getSession(resolvedId);
+    if (!session) {
+      throw new Error(`Chat session not found: ${sessionId}`);
+    }
+    stdout(`Chatting in session ${session.id}. Type 'exit' to quit.`);
+    while (true) {
+      const question = await prompt("You: ");
+      if (!question.trim()) continue;
+      if (shouldExit(question)) break;
+      const { answer, sources } = await chatAsk(session.id, question, { topK, maxChapter });
+      stdout(`
+${answer}`);
+      if (sources.length > 0) {
+        stdout("\nSources:");
+        sources.forEach((match, index) => {
+          const title = match.chapterTitle || `Chapter ${match.chapterIndex + 1}`;
+          const excerpt = match.content.slice(0, 120).replace(/\s+/g, " ");
+          stdout(`[${index + 1}] ${title}: ${excerpt}`);
+        });
+      }
+      stdout("");
+    }
+  });
+};
+
+// src/commands/chat/index.ts
+var registerChatCommands = (program2) => {
+  const chat = program2.command("chat").description("Run multi-turn chat sessions");
+  registerChatStart(chat);
+  registerChatAsk(chat);
+  registerChatList(chat);
+  registerChatShow(chat);
+  registerChatRepl(chat);
+};
+
+// src/main.ts
+var resolveVersion = async () => {
+  try {
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = resolve(currentDir, "../package.json");
+    const raw = await readFile2(pkgPath, "utf-8");
+    return JSON.parse(raw).version || "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+};
+var program = new Command();
+var configureProgram = async () => {
+  program.name("mycroft").description("Ingest EPUBs, build a local index, and answer questions").version(await resolveVersion()).option("--data-dir <path>", "Override data directory").hook("preAction", (cmd) => {
+    const opts = cmd.opts();
+    if (opts.dataDir) {
+      setConfigOverrides({ dataDir: opts.dataDir });
+    }
+  });
+};
+var registerCommands = () => {
+  const book = program.command("book").description("Manage books and queries");
+  const ingest = registerBookIngest(book);
+  registerBookList(book);
+  registerBookShow(book);
+  registerBookAsk(book);
+  registerBookSearch(book);
+  registerBookDelete(book);
+  registerBookResume(book, ingest);
+  const config = program.command("config").description("Manage configuration");
+  registerConfigPath(config);
+  registerConfigInit(config);
+  registerConfigResolve(config);
+  registerConfigOnboard(config);
+  registerChatCommands(program);
+};
+program.exitOverride((error) => {
+  if (error.code === "commander.helpDisplayed") {
+    process.exit(0);
+  }
+  throw error;
+});
+var main = async () => {
+  try {
+    await configureProgram();
+    registerCommands();
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(message);
+    process.exit(1);
+  }
+};
+export {
+  main
+};
+//# sourceMappingURL=main-36PRDAPE.js.map