@fs/mycroft 0.1.0

package/dist/cli.js

@@ -0,0 +1,1324 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { mkdir, readFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+var DEFAULT_CONFIG = {
+  dataDir: "~/.local/share/mycroft",
+  askEnabled: true,
+  models: {
+    embedding: "text-embedding-3-small",
+    summary: "gpt-5-nano",
+    chat: "gpt-5.1"
+  }
+};
+var expandHome = (input) => {
+  if (!input.startsWith("~")) return input;
+  return join(homedir(), input.slice(1));
+};
+var resolvePath = (input) => resolve(expandHome(input));
+var getConfigPath = () => {
+  const override = process.env.MYCROFT_CONFIG;
+  if (override) return resolvePath(override);
+  return resolvePath("~/.config/mycroft/config.json");
+};
+var normalizeModels = (models) => ({
+  embedding: models?.embedding || DEFAULT_CONFIG.models.embedding,
+  summary: models?.summary || DEFAULT_CONFIG.models.summary,
+  chat: models?.chat || DEFAULT_CONFIG.models.chat
+});
+var overrides = {};
+var setConfigOverrides = (next) => {
+  overrides = { ...overrides, ...next };
+};
+var normalizeConfig = (input) => {
+  const dataDirEnv = process.env.MYCROFT_DATA_DIR;
+  const dataDir = overrides.dataDir || dataDirEnv || input?.dataDir || DEFAULT_CONFIG.dataDir;
+  return {
+    dataDir,
+    askEnabled: input?.askEnabled ?? DEFAULT_CONFIG.askEnabled,
+    models: normalizeModels(input?.models)
+  };
+};
+var readConfigFile = async (path) => {
+  try {
+    const contents = await readFile(path, "utf-8");
+    return JSON.parse(contents);
+  } catch {
+    return null;
+  }
+};
+var loadConfig = async () => {
+  const configPath2 = getConfigPath();
+  const data = await readConfigFile(configPath2);
+  const normalized = normalizeConfig(data);
+  return {
+    ...normalized,
+    dataDir: resolvePath(normalized.dataDir)
+  };
+};
+var ensureConfigDirs = async (configPath2) => {
+  const path = configPath2 || getConfigPath();
+  await mkdir(dirname(path), { recursive: true });
+};
+var configPath = () => getConfigPath();
+
+// src/commands/io.ts
+import chalk from "chalk";
+var isTTY = () => Boolean(process.stdout.isTTY);
+var isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+var formatError = (text) => isTTY() ? chalk.red(text) : text;
+var formatWarn = (text) => isTTY() ? chalk.yellow(text) : text;
+var stdout = (message) => {
+  process.stdout.write(message.endsWith("\n") ? message : `${message}
+`);
+};
+var stderr = (message) => {
+  process.stderr.write(message.endsWith("\n") ? message : `${message}
+`);
+};
+var printError = (message) => {
+  stderr(formatError(`Error: ${message}`));
+};
+var logInfo = (message) => {
+  stderr(message);
+};
+var logWarn = (message) => {
+  stderr(formatWarn(message));
+};
+var handleSigint = (onCancel) => {
+  const handler = () => {
+    if (onCancel) onCancel();
+    stderr("\nCancelled.");
+    process.exit(130);
+  };
+  process.once("SIGINT", handler);
+  return () => process.off("SIGINT", handler);
+};
+
+// src/cli.ts
+import { readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/services/epub-parser.ts
+import { initEpubFile } from "@lingo-reader/epub-parser";
+import { basename } from "path";
+
+// src/services/constants.ts
+import { mkdir as mkdir2 } from "fs/promises";
+var CHUNK_SIZE = 1e3;
+var CHUNK_OVERLAP = 100;
+var SEPARATORS = ["\n\n", "\n", ". ", " ", ""];
+var SUMMARY_MAX_TOKENS = 3e4;
+var SUMMARY_CONCURRENCY = 3;
+var SUMMARY_TARGET_WORDS = 250;
+var resolvePaths = async () => {
+  const config = await loadConfig();
+  const dataDir = config.dataDir;
+  return {
+    dataDir,
+    booksDir: `${dataDir}/books`,
+    vectorsDir: `${dataDir}/vectors`,
+    dbPath: `${dataDir}/metadata.db`
+  };
+};
+var ensureDataDirs = async () => {
+  const paths = await resolvePaths();
+  await mkdir2(paths.dataDir, { recursive: true });
+  await mkdir2(paths.booksDir, { recursive: true });
+  await mkdir2(paths.vectorsDir, { recursive: true });
+  return paths;
+};
+var getModels = async () => {
+  const config = await loadConfig();
+  return config.models;
+};
+var isAskEnabled = async () => {
+  const config = await loadConfig();
+  return config.askEnabled;
+};
+var requireOpenAIKey = () => {
+  if (!process.env.OPENAI_API_KEY) {
+    throw new Error("OPENAI_API_KEY is not set. Export it to use embeddings and chat.");
+  }
+};
+
+// src/services/epub-parser.ts
+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 as mkdir3, unlink, copyFile } 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) => {
+  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)
+    });
+    for (let j = 0; j < batch.length; j++) {
+      allEmbedded.push({
+        ...batch[j],
+        vector: embeddings[j] ?? []
+      });
+    }
+  }
+  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) => {
+  const summaries = [];
+  logInfo(`[Summarizer] Starting summarization of ${chapters.length} chapters (concurrency: ${SUMMARY_CONCURRENCY})`);
+  for (let i = 0; i < chapters.length; i += SUMMARY_CONCURRENCY) {
+    const batch = chapters.slice(i, i + SUMMARY_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 + SUMMARY_CONCURRENCY, chapters.length)}/${chapters.length} chapters processed`);
+  }
+  logInfo(`[Summarizer] Completed: ${summaries.length}/${chapters.length} summaries generated`);
+  return summaries;
+};
+
+// 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
+    );
+  `);
+  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");
+  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
+});
+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 (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 deleteBook = async (id) => {
+  const db = await getDb();
+  db.prepare("DELETE FROM books WHERE id = ?").run(id);
+};
+
+// src/services/ingest.ts
+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}`;
+  logInfo(`[Ingest] Starting ingestion for book ${bookId}`);
+  await mkdir3(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);
+      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];
+    const embedStart = Date.now();
+    const embedded = await embedChunks(allChunks);
+    logInfo(`[Ingest] Embedded ${embedded.length} total chunks (${formatDuration(Date.now() - embedStart)})`);
+    await addChunksToIndex(bookId, embedded);
+    logInfo(`[Ingest] Added chunks to vector index`);
+    await updateBook(bookId, { chunkCount: embedded.length, indexedAt: Date.now() });
+    logInfo(`[Ingest] Updated book record with chunk count: ${embedded.length}`);
+  } catch (error) {
+    logWarn(`[Ingest] Error during chunking/embedding: ${error instanceof Error ? error.message : String(error)}`);
+    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 };
+};
+
+// 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 });
+  stdout(`
+Done. Book indexed as ${result.id}`);
+};
+
+// src/commands/book/ingest.ts
+var registerBookIngest = (program2) => {
+  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").action(async (path, options) => {
+    const summarize = Boolean(options.summary);
+    await ingestCommand(path, { manual: options.manual, summarize });
+  });
+};
+
+// 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]" : "[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("\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/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 = 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;
+    }
+    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 = 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;
+    }
+    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/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 mkdir4, writeFile, 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 writeFile(path, JSON.stringify(template, null, 2), "utf-8");
+  await mkdir4(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 writeFile2 } 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("\nEPUB RAG setup");
+  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 writeFile2(
+    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/cli.ts
+var resolveVersion = async () => {
+  try {
+    const currentDir = dirname2(fileURLToPath(import.meta.url));
+    const pkgPath = resolve2(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");
+  registerBookIngest(book);
+  registerBookList(book);
+  registerBookShow(book);
+  registerBookAsk(book);
+  registerBookSearch(book);
+  registerBookDelete(book);
+  const config = program.command("config").description("Manage configuration");
+  registerConfigPath(config);
+  registerConfigInit(config);
+  registerConfigResolve(config);
+  registerConfigOnboard(config);
+};
+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);
+  }
+};
+main();
+//# sourceMappingURL=cli.js.map