@serticode/thoth 1.0.0

package/dist/index.js

@@ -0,0 +1,3209 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/infrastructure/config/config-loader.ts
+import { readFileSync, existsSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+
+// src/infrastructure/config/config.schema.ts
+import { z } from "zod";
+var thothConfigSchema = z.object({
+  provider: z.enum(["openai", "groq", "gemini", "ollama", "anthropic"]).optional(),
+  chatModel: z.string().optional(),
+  embeddingModel: z.string().optional(),
+  local: z.boolean().optional(),
+  dbPath: z.string().optional(),
+  logLevel: z.string().optional(),
+  export: z.object({
+    format: z.enum(["md", "html", "txt", "rss"]).optional(),
+    outputDir: z.string().optional()
+  }).optional()
+});
+
+// src/infrastructure/config/config-loader.ts
+var CONFIG_FILENAME = "thoth.json";
+function configWarn(message) {
+  process.stderr.write(`\x1B[33m[config]\x1B[0m ${message}
+`);
+}
+function findConfigFiles() {
+  const paths = [];
+  const cwdConfig = resolve(process.cwd(), CONFIG_FILENAME);
+  if (existsSync(cwdConfig)) {
+    paths.push(cwdConfig);
+  }
+  const homeDir = homedir();
+  const homeConfig = join(homeDir, ".thoth", CONFIG_FILENAME);
+  if (existsSync(homeConfig)) {
+    paths.push(homeConfig);
+  }
+  return paths;
+}
+function readAndParseConfig(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const result = thothConfigSchema.safeParse(parsed);
+    if (!result.success) {
+      configWarn(`Config file ${filePath} has invalid fields: ${result.error.message}`);
+      return {};
+    }
+    return result.data;
+  } catch (error2) {
+    configWarn(`Could not read config file ${filePath}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    return {};
+  }
+}
+function loadConfig() {
+  const configFiles = findConfigFiles();
+  let config = {};
+  for (const filePath of configFiles) {
+    const partial = readAndParseConfig(filePath);
+    config = { ...config, ...partial };
+  }
+  return config;
+}
+var DEFAULTS = {
+  logLevel: "error"
+};
+function resolveConfig(cliLocal, cliProvider) {
+  const fileConfig = loadConfig();
+  const envLocal = process.env.THOTH_LOCAL === "true";
+  const logLevel = process.env.LOG_LEVEL ?? fileConfig.logLevel ?? DEFAULTS.logLevel;
+  const dbPath = process.env.THOTH_DB_PATH ?? fileConfig.dbPath;
+  const local = cliLocal ?? envLocal ?? fileConfig.local ?? false;
+  const provider = cliProvider ?? process.env.THOTH_PROVIDER ?? fileConfig.provider;
+  const chatModel2 = process.env.THOTH_CHAT_MODEL ?? fileConfig.chatModel;
+  const embeddingModel2 = process.env.THOTH_EMBEDDING_MODEL ?? fileConfig.embeddingModel;
+  return {
+    logLevel,
+    dbPath,
+    local,
+    provider,
+    chatModel: chatModel2,
+    embeddingModel: embeddingModel2,
+    export: fileConfig.export
+  };
+}
+function applyConfig(config) {
+  if (config.logLevel) process.env.LOG_LEVEL = config.logLevel;
+  if (config.dbPath) process.env.THOTH_DB_PATH = config.dbPath;
+  if (config.provider) process.env.THOTH_PROVIDER = config.provider;
+  if (config.chatModel) process.env.THOTH_CHAT_MODEL = config.chatModel;
+  if (config.embeddingModel) process.env.THOTH_EMBEDDING_MODEL = config.embeddingModel;
+  if (config.local !== void 0) process.env.THOTH_LOCAL = config.local ? "true" : "false";
+}
+
+// src/infrastructure/persistence/database.ts
+import Database from "better-sqlite3";
+import * as sqliteVec from "sqlite-vec";
+import { join as join2, dirname } from "path";
+import { homedir as homedir3 } from "os";
+import { mkdirSync, chmodSync } from "fs";
+
+// src/infrastructure/logging/logger.ts
+import pino from "pino";
+var pinoInstance = pino({
+  level: process.env.LOG_LEVEL ?? "error",
+  transport: process.env.NODE_ENV !== "production" ? { target: "pino/file", options: { destination: 2 } } : void 0
+});
+var logger = {
+  info(obj, msg) {
+    if (typeof obj === "string") {
+      pinoInstance.info(obj);
+    } else {
+      pinoInstance.info(obj, msg ?? "");
+    }
+  },
+  warn(obj, msg) {
+    if (typeof obj === "string") {
+      pinoInstance.warn(obj);
+    } else {
+      pinoInstance.warn(obj, msg ?? "");
+    }
+  },
+  error(obj, msg) {
+    if (typeof obj === "string") {
+      pinoInstance.error(obj);
+    } else {
+      pinoInstance.error(obj, msg ?? "");
+    }
+  },
+  debug(obj, msg) {
+    if (typeof obj === "string") {
+      pinoInstance.debug(obj);
+    } else {
+      pinoInstance.debug(obj, msg ?? "");
+    }
+  }
+};
+
+// src/infrastructure/logging/path-utils.ts
+import { homedir as homedir2 } from "os";
+var HOME_DIR = homedir2();
+function sanitizePath(filePath) {
+  if (filePath.startsWith(HOME_DIR)) {
+    return filePath.replace(HOME_DIR, "~");
+  }
+  return filePath;
+}
+
+// src/infrastructure/persistence/migrations/001_initial.ts
+var MIGRATION_001 = `-- Thoth initial schema: sources, profiles, and vector indexes
+
+CREATE TABLE IF NOT EXISTS sources (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL CHECK(type IN ('voice', 'knowledge', 'publication')),
+  source_path TEXT NOT NULL,
+  content TEXT NOT NULL,
+  checksum TEXT NOT NULL,
+  chunk_index INTEGER NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_sources_type ON sources(type);
+CREATE INDEX IF NOT EXISTS idx_sources_checksum ON sources(checksum);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_sources USING vec0(
+  embedding float[1536]
+);
+
+CREATE TABLE IF NOT EXISTS source_embeddings (
+  id INTEGER PRIMARY KEY,
+  source_id TEXT NOT NULL REFERENCES sources(id),
+  model TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_source_embeddings_source_id ON source_embeddings(source_id);
+
+CREATE TABLE IF NOT EXISTS voice_profiles (
+  id TEXT PRIMARY KEY,
+  name TEXT,
+  traits TEXT NOT NULL,
+  summary TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS knowledge_profiles (
+  id TEXT PRIMARY KEY,
+  domains TEXT NOT NULL,
+  topics TEXT NOT NULL,
+  summary TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS publication_profiles (
+  id TEXT PRIMARY KEY,
+  themes TEXT NOT NULL,
+  series TEXT,
+  summary TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_profiles USING vec0(
+  embedding float[1536]
+);
+
+CREATE TABLE IF NOT EXISTS profile_embeddings (
+  id INTEGER PRIMARY KEY,
+  profile_id TEXT NOT NULL,
+  profile_type TEXT NOT NULL CHECK(profile_type IN ('voice', 'knowledge', 'publication')),
+  model TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_profile_embeddings_profile_id ON profile_embeddings(profile_id);
+`;
+
+// src/infrastructure/persistence/migrations/002_research.ts
+var MIGRATION_002 = `-- Research notes and vector index
+
+CREATE TABLE IF NOT EXISTS research_notes (
+  id TEXT PRIMARY KEY,
+  topic TEXT NOT NULL,
+  content TEXT NOT NULL,
+  citations TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_research_notes_topic ON research_notes(topic);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_research USING vec0(
+  embedding float[1536]
+);
+
+CREATE TABLE IF NOT EXISTS research_embeddings (
+  id INTEGER PRIMARY KEY,
+  research_id TEXT NOT NULL REFERENCES research_notes(id),
+  model TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+
+// src/infrastructure/persistence/migrations/003_articles.ts
+var MIGRATION_003 = `-- Generated articles table
+
+CREATE TABLE IF NOT EXISTS articles (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL,
+  content TEXT NOT NULL,
+  voice_profile_id TEXT NOT NULL,
+  research_id TEXT,
+  word_count INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL DEFAULT 'draft' CHECK(status IN ('draft', 'published', 'archived')),
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_articles_status ON articles(status);
+CREATE INDEX IF NOT EXISTS idx_articles_created_at ON articles(created_at);
+`;
+
+// src/infrastructure/persistence/migrations/004_series.ts
+var MIGRATION_004 = `-- Series and series-article relationships
+
+CREATE TABLE IF NOT EXISTS series (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  description TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE TABLE IF NOT EXISTS series_articles (
+  series_id TEXT NOT NULL REFERENCES series(id) ON DELETE CASCADE,
+  article_id TEXT NOT NULL REFERENCES articles(id) ON DELETE CASCADE,
+  position INTEGER NOT NULL DEFAULT 0,
+  added_at TEXT NOT NULL DEFAULT (datetime('now')),
+  PRIMARY KEY (series_id, article_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_series_articles_series ON series_articles(series_id);
+CREATE INDEX IF NOT EXISTS idx_series_articles_article ON series_articles(article_id);
+`;
+
+// src/infrastructure/persistence/migrations/005_import_log.ts
+var MIGRATION_005 = `-- Import checkpoint log for resume/dedup
+
+CREATE TABLE IF NOT EXISTS import_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source_path TEXT NOT NULL,
+  checksum TEXT NOT NULL,
+  type TEXT NOT NULL,
+  imported_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_import_log_path ON import_log(source_path);
+CREATE INDEX IF NOT EXISTS idx_import_log_checksum ON import_log(checksum);
+`;
+
+// src/infrastructure/persistence/migrations/006_vectors_per_provider.ts
+var MIGRATION_006 = `-- Per-provider vector tables
+
+DROP TABLE IF EXISTS vec_sources;
+DROP TABLE IF EXISTS vec_profiles;
+DROP TABLE IF EXISTS vec_research;
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_sources_openai USING vec0(
+  embedding float[1536]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_sources_ollama USING vec0(
+  embedding float[768]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_sources_gemini USING vec0(
+  embedding float[768]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_profiles_openai USING vec0(
+  embedding float[1536]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_profiles_ollama USING vec0(
+  embedding float[768]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_profiles_gemini USING vec0(
+  embedding float[768]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_research_openai USING vec0(
+  embedding float[1536]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_research_ollama USING vec0(
+  embedding float[768]
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS vec_research_gemini USING vec0(
+  embedding float[768]
+);
+`;
+
+// src/infrastructure/persistence/migrations/007_medium.ts
+var MIGRATION_007 = `-- Medium publishing support
+
+ALTER TABLE articles ADD COLUMN medium_url TEXT;
+`;
+
+// src/infrastructure/persistence/database.ts
+var db = null;
+var cachedDbPath = null;
+function setDbPath(path) {
+  cachedDbPath = path;
+}
+function resolveDbPath() {
+  if (cachedDbPath) return cachedDbPath;
+  return process.env.THOTH_DB_PATH ?? join2(homedir3(), ".thoth", "thoth.db");
+}
+function getDatabase() {
+  if (db) return db;
+  const dbPath = resolveDbPath();
+  const dbDir = dirname(dbPath);
+  mkdirSync(dbDir, { recursive: true });
+  logger.info({ path: sanitizePath(dbPath) }, "Opening database");
+  db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  try {
+    chmodSync(dbPath, 384);
+  } catch {
+    logger.warn({ path: sanitizePath(dbPath) }, "Could not set database file permissions");
+  }
+  sqliteVec.load(db);
+  runMigrations(db);
+  return db;
+}
+function runMigrations(db3) {
+  db3.exec(
+    "CREATE TABLE IF NOT EXISTS _migrations (id INTEGER PRIMARY KEY, name TEXT NOT NULL, applied_at TEXT NOT NULL DEFAULT (datetime('now')))"
+  );
+  const migrations = [
+    { name: "001_initial.sql", sql: MIGRATION_001 },
+    { name: "002_research.sql", sql: MIGRATION_002 },
+    { name: "003_articles.sql", sql: MIGRATION_003 },
+    { name: "004_series.sql", sql: MIGRATION_004 },
+    { name: "005_import_log.sql", sql: MIGRATION_005 },
+    { name: "006_vectors_per_provider.sql", sql: MIGRATION_006 },
+    { name: "007_medium.sql", sql: MIGRATION_007 }
+  ];
+  for (const migration of migrations) {
+    const applied = db3.prepare("SELECT 1 FROM _migrations WHERE name = ?").get(migration.name);
+    if (applied) continue;
+    const applyMigration = db3.transaction(() => {
+      db3.exec(migration.sql);
+      db3.prepare("INSERT INTO _migrations (name) VALUES (?)").run(migration.name);
+    });
+    applyMigration();
+    logger.info({ migration: migration.name }, "Applied migration");
+  }
+}
+function closeDatabase() {
+  if (db) {
+    db.close();
+    db = null;
+  }
+}
+
+// src/infrastructure/ai/ai.service.ts
+import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/infrastructure/ai/provider.ts
+var DEFAULTS2 = {
+  ollamaBaseURL: "http://localhost:11434/v1",
+  ollamaChat: "qwen2.5:7b",
+  ollamaEmbed: "nomic-embed-text",
+  geminiChat: "gemini-1.5-flash",
+  geminiEmbed: "text-embedding-004",
+  groqChat: "mixtral-8x7b-32768",
+  openaiChat: "gpt-4o-mini",
+  openaiEmbed: "text-embedding-3-small",
+  anthropicChat: "claude-sonnet-4-20250514"
+};
+function isSelectedProvider(provider) {
+  return process.env.THOTH_PROVIDER === provider || provider === "ollama" && process.env.THOTH_LOCAL === "true";
+}
+function chatModel(provider, providerSpecific, fallback) {
+  return providerSpecific ?? (isSelectedProvider(provider) ? process.env.THOTH_CHAT_MODEL : void 0) ?? fallback;
+}
+function embeddingModel(provider, providerSpecific, fallback) {
+  return providerSpecific ?? (isSelectedProvider(provider) ? process.env.THOTH_EMBEDDING_MODEL : void 0) ?? fallback;
+}
+function getChatProviders() {
+  const providers = [];
+  const localOnly = process.env.THOTH_LOCAL === "true";
+  const preferredProvider = process.env.THOTH_PROVIDER;
+  if (preferredProvider && preferredProvider !== "openai") {
+  } else if (!localOnly && process.env.OPENAI_API_KEY) {
+    providers.push({
+      name: "OpenAI",
+      key: "openai",
+      kind: "openai-compatible",
+      baseURL: "https://api.openai.com/v1",
+      apiKey: process.env.OPENAI_API_KEY,
+      chatModel: chatModel("openai", process.env.OPENAI_CHAT_MODEL, DEFAULTS2.openaiChat),
+      supportsEmbeddings: true,
+      embeddingModel: embeddingModel("openai", process.env.OPENAI_EMBEDDING_MODEL, DEFAULTS2.openaiEmbed),
+      embeddingDimensions: 1536
+    });
+  }
+  if (preferredProvider && preferredProvider !== "groq") {
+  } else if (!localOnly && process.env.GROQ_API_KEY) {
+    providers.push({
+      name: "Groq",
+      key: "groq",
+      kind: "openai-compatible",
+      baseURL: "https://api.groq.com/openai/v1",
+      apiKey: process.env.GROQ_API_KEY,
+      chatModel: chatModel("groq", process.env.GROQ_CHAT_MODEL, DEFAULTS2.groqChat),
+      supportsEmbeddings: false
+    });
+  }
+  if (preferredProvider && preferredProvider !== "gemini") {
+  } else if (!localOnly && process.env.GEMINI_API_KEY) {
+    providers.push({
+      name: "Gemini",
+      key: "gemini",
+      kind: "openai-compatible",
+      baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
+      apiKey: process.env.GEMINI_API_KEY,
+      chatModel: chatModel("gemini", process.env.GEMINI_CHAT_MODEL, DEFAULTS2.geminiChat),
+      supportsEmbeddings: true,
+      embeddingModel: embeddingModel("gemini", process.env.GEMINI_EMBEDDING_MODEL, DEFAULTS2.geminiEmbed),
+      embeddingDimensions: 768
+    });
+  }
+  if (preferredProvider && preferredProvider !== "anthropic") {
+  } else if (!localOnly && process.env.ANTHROPIC_API_KEY) {
+    providers.push({
+      name: "Anthropic",
+      key: "anthropic",
+      kind: "anthropic",
+      baseURL: "https://api.anthropic.com/v1",
+      apiKey: process.env.ANTHROPIC_API_KEY,
+      chatModel: chatModel("anthropic", process.env.ANTHROPIC_CHAT_MODEL, DEFAULTS2.anthropicChat),
+      supportsEmbeddings: false
+    });
+  }
+  if (preferredProvider && preferredProvider !== "ollama") {
+  } else {
+    providers.push({
+      name: "Ollama",
+      key: "ollama",
+      kind: "openai-compatible",
+      baseURL: process.env.OLLAMA_BASE_URL ?? DEFAULTS2.ollamaBaseURL,
+      chatModel: chatModel("ollama", process.env.OLLAMA_CHAT_MODEL, DEFAULTS2.ollamaChat),
+      supportsEmbeddings: true,
+      embeddingModel: embeddingModel("ollama", process.env.OLLAMA_EMBEDDING_MODEL, DEFAULTS2.ollamaEmbed),
+      embeddingDimensions: 768
+    });
+  }
+  return providers;
+}
+function getEmbeddingProviders() {
+  return getChatProviders().filter((p) => p.supportsEmbeddings);
+}
+function getActiveEmbeddingProviderKey() {
+  const providers = getEmbeddingProviders();
+  return providers[0]?.key ?? "openai";
+}
+
+// src/infrastructure/ai/ai.service.ts
+function createClient(config) {
+  return new OpenAI({
+    baseURL: config.baseURL,
+    apiKey: config.apiKey ?? "no-key-required"
+  });
+}
+async function withTimeout(fn, ms) {
+  const controller = new AbortController();
+  const timer2 = setTimeout(() => controller.abort(), ms);
+  try {
+    return await fn(controller.signal);
+  } finally {
+    clearTimeout(timer2);
+  }
+}
+function buildProviderListError(operation) {
+  return `No AI provider available for ${operation}. Set OPENAI_API_KEY, GROQ_API_KEY, GEMINI_API_KEY, ANTHROPIC_API_KEY, or start Ollama on localhost:11434.`;
+}
+function parseTimeoutMs(value, fallback) {
+  if (value === void 0) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+function defaultChatTimeoutMs(provider) {
+  return provider.name === "Ollama" ? 18e4 : 3e4;
+}
+function defaultEmbeddingTimeoutMs(provider) {
+  return provider.name === "Ollama" ? 6e4 : 15e3;
+}
+async function chatWithOpenAiCompatible(config, params, signal) {
+  const client = createClient(config);
+  const response = await client.chat.completions.create(
+    {
+      model: config.chatModel,
+      messages: [
+        { role: "system", content: params.systemPrompt },
+        { role: "user", content: params.userPrompt }
+      ],
+      temperature: params.temperature ?? 0.7,
+      ...params.responseFormat === "json" ? { response_format: { type: "json_object" } } : {}
+    },
+    { signal }
+  );
+  return response.choices[0]?.message?.content ?? null;
+}
+async function chatWithAnthropic(config, params, signal) {
+  const anthropic = new Anthropic({
+    apiKey: config.apiKey
+  });
+  const response = await anthropic.messages.create(
+    {
+      model: config.chatModel,
+      system: params.systemPrompt,
+      messages: [{ role: "user", content: params.userPrompt }],
+      max_tokens: 4096,
+      temperature: params.temperature ?? 0.7
+    },
+    { signal }
+  );
+  const contentBlock = response.content.find((block) => block.type === "text");
+  const content = contentBlock?.text ?? null;
+  return content || null;
+}
+var OpenAiAiService = class {
+  async chat(params) {
+    const providers = getChatProviders();
+    if (providers.length === 0) {
+      return { ok: false, error: buildProviderListError("chat") };
+    }
+    const MAX_RETRIES = 3;
+    for (const provider of providers) {
+      const timeoutMs = parseTimeoutMs(process.env.THOTH_CHAT_TIMEOUT_MS, defaultChatTimeoutMs(provider));
+      for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          logger.debug({ provider: provider.name, attempt, timeoutMs }, "Attempting chat completion");
+          const content = await withTimeout(async (signal) => {
+            if (provider.kind === "anthropic") {
+              return chatWithAnthropic(provider, params, signal);
+            }
+            return chatWithOpenAiCompatible(provider, params, signal);
+          }, timeoutMs);
+          if (content) {
+            logger.info({ provider: provider.name }, "Chat completed");
+            return { ok: true, value: content };
+          }
+        } catch (error2) {
+          const isLastAttempt = attempt === MAX_RETRIES;
+          logger.warn(
+            {
+              provider: provider.name,
+              attempt,
+              error: error2 instanceof Error ? error2.message : error2
+            },
+            isLastAttempt ? "Provider failed, trying next" : "Retrying..."
+          );
+          if (!isLastAttempt) {
+            const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 8e3);
+            await new Promise((resolve3) => setTimeout(resolve3, delay));
+          }
+        }
+      }
+    }
+    return { ok: false, error: "All AI providers failed to complete the chat request." };
+  }
+  getActiveEmbeddingModel() {
+    const providers = getEmbeddingProviders();
+    return providers[0]?.embeddingModel ?? "text-embedding-3-small";
+  }
+  async generateEmbedding(text) {
+    const providers = getEmbeddingProviders();
+    if (providers.length === 0) {
+      return { ok: false, error: buildProviderListError("embeddings") };
+    }
+    const MAX_RETRIES = 3;
+    for (const provider of providers) {
+      if (!provider.embeddingModel) continue;
+      const model = provider.embeddingModel;
+      const timeoutMs = parseTimeoutMs(process.env.THOTH_EMBEDDING_TIMEOUT_MS, defaultEmbeddingTimeoutMs(provider));
+      for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          logger.debug({ provider: provider.name, attempt, textLength: text.length, timeoutMs }, "Attempting embedding");
+          const client = createClient(provider);
+          const response = await withTimeout(
+            (signal) => client.embeddings.create(
+              {
+                model,
+                input: text
+              },
+              { signal }
+            ),
+            timeoutMs
+          );
+          const embedding = response.data[0]?.embedding;
+          if (embedding) {
+            logger.info({ provider: provider.name }, "Embedding generated");
+            return { ok: true, value: embedding };
+          }
+        } catch (error2) {
+          const isLastAttempt = attempt === MAX_RETRIES;
+          logger.warn(
+            {
+              provider: provider.name,
+              attempt,
+              error: error2 instanceof Error ? error2.message : error2
+            },
+            isLastAttempt ? "Provider failed, trying next" : "Retrying..."
+          );
+          if (!isLastAttempt) {
+            const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 8e3);
+            await new Promise((resolve3) => setTimeout(resolve3, delay));
+          }
+        }
+      }
+    }
+    return { ok: false, error: "All embedding providers failed." };
+  }
+};
+
+// src/infrastructure/adapters/file-source.adapter.ts
+import { readFileSync as readFileSync2, readdirSync, statSync, realpathSync } from "fs";
+import { join as join3, extname } from "path";
+import { randomUUID, createHash } from "crypto";
+
+// src/application/services/embedding.service.ts
+import { get_encoding } from "tiktoken";
+var enc = get_encoding("cl100k_base");
+function chunkText(text, maxTokens = 512, overlap = 50) {
+  if (overlap >= maxTokens) overlap = maxTokens - 1;
+  const tokens = enc.encode(text);
+  const chunks = [];
+  if (tokens.length <= maxTokens) {
+    chunks.push({ content: text, index: 0, tokenCount: tokens.length });
+    return chunks;
+  }
+  let start = 0;
+  let chunkIndex = 0;
+  while (start < tokens.length) {
+    const end = Math.min(start + maxTokens, tokens.length);
+    const chunkTokens = tokens.slice(start, end);
+    const content = new TextDecoder().decode(enc.decode(chunkTokens));
+    chunks.push({
+      content,
+      index: chunkIndex,
+      tokenCount: chunkTokens.length
+    });
+    chunkIndex++;
+    start += maxTokens - overlap;
+    if (start >= tokens.length) break;
+  }
+  return chunks;
+}
+
+// src/infrastructure/adapters/file-source.adapter.ts
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var FileSourceAdapter = class {
+  importFromPath(sourcePath, type) {
+    const resolvedPath = realpathSync(sourcePath);
+    const stat = statSync(resolvedPath);
+    if (stat.isDirectory()) {
+      return Promise.resolve(this.importFromDirectory(resolvedPath, type));
+    }
+    return Promise.resolve(this.importFile(resolvedPath, type));
+  }
+  importFromDirectory(dirPath, type, visited) {
+    const resolvedDir = realpathSync(dirPath);
+    if (!visited) visited = /* @__PURE__ */ new Set();
+    if (visited.has(resolvedDir)) return [];
+    visited.add(resolvedDir);
+    const entries = readdirSync(resolvedDir);
+    const results = [];
+    for (const entry of entries) {
+      const entryPath = join3(resolvedDir, entry);
+      let resolvedPath;
+      try {
+        resolvedPath = realpathSync(entryPath);
+      } catch {
+        continue;
+      }
+      if (!resolvedPath.startsWith(resolvedDir + "/")) continue;
+      const stat = statSync(resolvedPath);
+      if (stat.isDirectory()) {
+        const nested = this.importFromDirectory(resolvedPath, type, visited);
+        results.push(...nested);
+        continue;
+      }
+      const ext = extname(resolvedPath).toLowerCase();
+      if (ext !== ".md" && ext !== ".txt") continue;
+      const sources = this.importFile(resolvedPath, type);
+      results.push(...sources);
+    }
+    return results;
+  }
+  importFile(filePath, type) {
+    const stat = statSync(filePath);
+    if (stat.size > MAX_FILE_SIZE) {
+      logger.warn({ file: sanitizePath(filePath), size: stat.size }, "File exceeds maximum size, skipping");
+      return [];
+    }
+    const content = readFileSync2(filePath, "utf-8");
+    const checksum = createHash("sha256").update(content).digest("hex");
+    const chunks = chunkText(content);
+    logger.info(
+      {
+        file: sanitizePath(filePath),
+        chunks: chunks.length,
+        totalTokens: chunks.reduce((s, c) => s + c.tokenCount, 0)
+      },
+      "Importing file"
+    );
+    return chunks.map((chunk) => ({
+      id: randomUUID(),
+      type,
+      sourcePath: filePath,
+      content: chunk.content,
+      checksum: `${checksum}:${chunk.index}`,
+      chunkIndex: chunk.index,
+      createdAt: /* @__PURE__ */ new Date()
+    }));
+  }
+};
+
+// src/application/use-cases/research.usecase.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/application/use-cases/parse-ai-json.ts
+function isJsonRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function extractJsonObject(value) {
+  const fencedMatch = /```(?:json)?\s*([\s\S]*?)```/i.exec(value);
+  const candidate = fencedMatch?.[1]?.trim() ?? value.trim();
+  const start = candidate.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let index = start; index < candidate.length; index += 1) {
+    const char = candidate[index];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (char === "{") depth += 1;
+    if (char === "}") depth -= 1;
+    if (depth === 0) {
+      return candidate.slice(start, index + 1);
+    }
+  }
+  return null;
+}
+function parseJsonRecord(value) {
+  const json = extractJsonObject(value);
+  if (json === null) return { ok: false, error: "No JSON object found in AI response" };
+  try {
+    const parsed = JSON.parse(json);
+    if (!isJsonRecord(parsed)) {
+      return { ok: false, error: "AI response JSON was not an object" };
+    }
+    return { ok: true, value: parsed };
+  } catch (error2) {
+    return {
+      ok: false,
+      error: error2 instanceof Error ? error2.message : "AI response JSON could not be parsed"
+    };
+  }
+}
+
+// src/application/use-cases/research.usecase.ts
+var RESEARCH_PROMPT = `You are a research assistant synthesizing information from a person's own writing.
+
+Given the topic and the provided source excerpts from their knowledge base, produce a well-structured research note that:
+
+1. Summarizes the key findings relevant to the topic
+2. Identifies patterns, contradictions, or gaps in the source material
+3. Cites specific excerpts that support each claim
+4. Suggests angles or directions for further exploration
+
+Return ONLY valid JSON with this exact structure:
+{
+  "content": "The full research note text with inline citations referencing source IDs",
+  "citations": [
+    {
+      "sourceId": "uuid-of-the-source",
+      "sourcePath": "path-to-source",
+      "excerpt": "the relevant excerpt",
+      "relevanceScore": 0.0 to 1.0
+    }
+  ]
+}`;
+var ResearchUseCase = class {
+  constructor(ai2, researchRepo, sourceRepo, logger2) {
+    this.ai = ai2;
+    this.researchRepo = researchRepo;
+    this.sourceRepo = sourceRepo;
+    this.logger = logger2;
+  }
+  ai;
+  researchRepo;
+  sourceRepo;
+  logger;
+  async execute(topic) {
+    this.logger.info({ topic }, "Starting research");
+    const embedResult = await this.ai.generateEmbedding(topic);
+    if (!embedResult.ok) return { ok: false, error: `Embedding failed: ${embedResult.error}` };
+    const nearChunks = await this.sourceRepo.searchByVector(embedResult.value, 15);
+    if (!nearChunks.ok) return { ok: false, error: nearChunks.error };
+    if (nearChunks.value.length === 0) {
+      return {
+        ok: false,
+        error: "No relevant sources found. Import knowledge sources with `thoth import knowledge <path>` first."
+      };
+    }
+    const excerpts = nearChunks.value.map((chunk) => `[${chunk.id}] ${chunk.content.slice(0, 500)}`).join("\n\n---\n\n");
+    const chatResult = await this.ai.chat({
+      systemPrompt: RESEARCH_PROMPT,
+      userPrompt: `Topic: ${topic}
+
+Relevant source excerpts:
+
+${excerpts}`,
+      temperature: 0.4
+    });
+    if (!chatResult.ok) return { ok: false, error: chatResult.error };
+    const parsed = parseJsonRecord(chatResult.value);
+    if (!parsed.ok) return { ok: false, error: `Invalid JSON response from research AI: ${parsed.error}` };
+    const content = parsed.value.content;
+    const rawCitations = parsed.value.citations;
+    if (typeof content !== "string" || !Array.isArray(rawCitations)) {
+      return { ok: false, error: "Research response missing content or citations" };
+    }
+    const citations = rawCitations.map((c) => ({
+      sourceId: String(c.sourceId),
+      sourcePath: String(c.sourcePath),
+      excerpt: String(c.excerpt),
+      relevanceScore: Number(c.relevanceScore)
+    }));
+    const note = {
+      id: randomUUID2(),
+      topic,
+      content,
+      citations,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    const saveResult = await this.researchRepo.save(note);
+    if (!saveResult.ok) return saveResult;
+    const noteEmbedResult = await this.ai.generateEmbedding(note.content);
+    if (noteEmbedResult.ok) {
+      const embResult = await this.researchRepo.saveResearchEmbedding(
+        note.id,
+        noteEmbedResult.value,
+        this.ai.getActiveEmbeddingModel()
+      );
+      if (!embResult.ok) {
+        this.logger.warn({ error: embResult.error }, "Failed to save research embedding");
+      }
+    } else {
+      this.logger.warn({ error: noteEmbedResult.error }, "Research note embedding failed");
+    }
+    this.logger.info({ topic, citationCount: citations.length, id: note.id }, "Research complete");
+    return { ok: true, value: note };
+  }
+};
+
+// src/application/use-cases/generate-article.usecase.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var ARTICLE_PROMPT = `You are writing an article for a specific author. Your goal is to produce text that sounds exactly like them.
+
+Below is the author's voice profile \u2014 their stylistic traits extracted from their writing. You MUST follow these traits precisely.
+
+Voice Profile:
+- Tone: {{tone}}
+- Pacing: {{pacing}}
+- Storytelling: {{storytelling}}
+- Vocabulary: {{vocabulary}}
+- Sentence Structure: {{sentenceStructure}}
+- Transitions: {{transitions}}
+- Humor: {{humor}}
+- Reader Engagement: {{readerEngagement}}
+- Summary: {{summary}}
+
+Write a complete article on the given topic using the provided research material. The article should:
+
+1. Match the author's voice exactly \u2014 follow every trait above
+2. Be informative and well-structured with a clear introduction, body, and conclusion
+3. Incorporate insights from the research material naturally
+ 4. Be between 1600-2500 words \u2014 aim for an 8-10 minute read. Go deeper if the topic demands it.
+
+Return ONLY valid JSON with this exact structure:
+{
+  "title": "Article title that matches the author's style",
+  "content": "Full article content in markdown format"
+}`;
+var GenerateArticleUseCase = class {
+  constructor(ai2, articleRepo, profileRepo, researchRepo, logger2) {
+    this.ai = ai2;
+    this.articleRepo = articleRepo;
+    this.profileRepo = profileRepo;
+    this.researchRepo = researchRepo;
+    this.logger = logger2;
+  }
+  ai;
+  articleRepo;
+  profileRepo;
+  researchRepo;
+  logger;
+  async execute(params) {
+    const voiceResult = await this.profileRepo.getLatestVoiceProfile();
+    if (!voiceResult.ok) return voiceResult;
+    const voiceProfile = voiceResult.value;
+    if (!voiceProfile) {
+      return { ok: false, error: "No voice profile found. Run `thoth profile generate` first." };
+    }
+    let researchContent = "";
+    let researchId = null;
+    if (params.researchId) {
+      const researchResult = await this.researchRepo.get(params.researchId);
+      if (!researchResult.ok) return researchResult;
+      if (researchResult.value) {
+        researchContent = researchResult.value.content;
+        researchId = researchResult.value.id;
+      }
+    }
+    const topicSection = params.topic ? `
+
+Topic: ${params.topic}` : "";
+    const researchSection = researchContent ? `
+
+Research Material:
+${researchContent}` : "";
+    const prompt = ARTICLE_PROMPT.replace("{{tone}}", voiceProfile.traits.tone.join(", ")).replace("{{pacing}}", voiceProfile.traits.pacing.join(", ")).replace("{{storytelling}}", voiceProfile.traits.storytelling.join(", ")).replace("{{vocabulary}}", voiceProfile.traits.vocabulary.join(", ")).replace("{{sentenceStructure}}", voiceProfile.traits.sentenceStructure.join(", ")).replace("{{transitions}}", voiceProfile.traits.transitions.join(", ")).replace("{{humor}}", voiceProfile.traits.humor.join(", ")).replace("{{readerEngagement}}", voiceProfile.traits.readerEngagement.join(", ")).replace("{{summary}}", voiceProfile.summary ?? "");
+    const userMessage = `Write an article${topicSection}${researchSection}`;
+    const chatResult = await this.ai.chat({
+      systemPrompt: `${prompt}
+
+Do not include markdown fences, commentary, or any text outside the JSON object.`,
+      userPrompt: userMessage,
+      responseFormat: "json",
+      temperature: 0.7
+    });
+    if (!chatResult.ok) return { ok: false, error: chatResult.error };
+    const parsed = parseJsonRecord(chatResult.value);
+    if (!parsed.ok) return { ok: false, error: `Invalid JSON response from article generation AI: ${parsed.error}` };
+    if (typeof parsed.value.title !== "string" || typeof parsed.value.content !== "string") {
+      return { ok: false, error: "Article response missing title or content" };
+    }
+    const title = parsed.value.title;
+    const content = parsed.value.content;
+    const wordCount = content.split(/\s+/).length;
+    const article2 = {
+      id: randomUUID3(),
+      title,
+      content,
+      voiceProfileId: voiceProfile.id,
+      researchId,
+      wordCount,
+      status: "draft",
+      mediumUrl: null,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const saveResult = await this.articleRepo.save(article2);
+    if (!saveResult.ok) return saveResult;
+    this.logger.info({ articleId: article2.id, title: article2.title, wordCount }, "Article generated");
+    return { ok: true, value: article2 };
+  }
+};
+
+// src/application/use-cases/generate-profiles.usecase.ts
+import { randomUUID as randomUUID4 } from "crypto";
+
+// src/application/use-cases/profile-schemas.ts
+import { z as z2 } from "zod";
+var voiceTraitsSchema = z2.object({
+  tone: z2.array(z2.string()),
+  pacing: z2.array(z2.string()),
+  storytelling: z2.array(z2.string()),
+  vocabulary: z2.array(z2.string()),
+  sentenceStructure: z2.array(z2.string()),
+  transitions: z2.array(z2.string()),
+  humor: z2.array(z2.string()),
+  readerEngagement: z2.array(z2.string())
+});
+var voiceProfileResponseSchema = z2.object({
+  traits: voiceTraitsSchema,
+  summary: z2.string().min(1)
+});
+var knowledgeProfileResponseSchema = z2.object({
+  domains: z2.array(z2.string()),
+  topics: z2.array(z2.string()),
+  summary: z2.string().min(1)
+});
+var publicationProfileResponseSchema = z2.object({
+  themes: z2.array(z2.string()),
+  summary: z2.string().min(1)
+});
+
+// src/application/use-cases/generate-profiles.usecase.ts
+var VOICE_PROMPT = `You are analyzing a person's writing to build a Voice Profile.
+
+Extract the following traits from the provided text samples. Be specific and evidence-based.
+
+Return ONLY valid JSON with this exact structure:
+{
+  "traits": {
+    "tone": ["descriptive adjectives"],
+    "pacing": ["sentence-level observations"],
+    "storytelling": ["narrative patterns"],
+    "vocabulary": ["vocabulary characteristics"],
+    "sentenceStructure": ["structural patterns"],
+    "transitions": ["transition patterns"],
+    "humor": ["humor characteristics or empty array"],
+    "readerEngagement": ["engagement techniques"]
+  },
+  "summary": "A 2-3 sentence summary of their voice"
+}`;
+var KNOWLEDGE_PROMPT = `You are analyzing technical writing to build a Knowledge Profile.
+
+Extract the domains, topics, and depth of knowledge from the provided text samples.
+
+Return ONLY valid JSON with this exact structure:
+{
+  "domains": ["broad technical domains"],
+  "topics": ["specific topics covered"],
+  "summary": "A 2-3 sentence summary of their knowledge areas and depth"
+}`;
+var PUBLICATION_PROMPT = `You are analyzing a person's published work to build a Publication Profile.
+
+Extract recurring themes, series, and writing evolution from the provided text samples.
+
+Return ONLY valid JSON with this exact structure:
+{
+  "themes": ["recurring themes"],
+  "summary": "A 2-3 sentence summary of their publication patterns"
+}`;
+var GenerateProfilesUseCase = class {
+  constructor(ai2, profileRepo, sourceRepo, logger2) {
+    this.ai = ai2;
+    this.profileRepo = profileRepo;
+    this.sourceRepo = sourceRepo;
+    this.logger = logger2;
+  }
+  ai;
+  profileRepo;
+  sourceRepo;
+  logger;
+  generateVoiceProfile() {
+    return this.generateProfile("voice", VOICE_PROMPT, "voice profile");
+  }
+  generateKnowledgeProfile() {
+    return this.generateProfile("knowledge", KNOWLEDGE_PROMPT, "knowledge profile");
+  }
+  generatePublicationProfile() {
+    return this.generateProfile("publication", PUBLICATION_PROMPT, "publication profile");
+  }
+  async generateProfile(type, systemPrompt, label) {
+    const typeLabel = type === "publication" ? "publication" : type;
+    const sourcesResult = await this.sourceRepo.getSourcesByType(type);
+    if (!sourcesResult.ok) return { ok: false, error: sourcesResult.error };
+    const sources = sourcesResult.value;
+    if (sources.length === 0) {
+      return {
+        ok: false,
+        error: `No ${typeLabel} sources imported. Run \`thoth import ${typeLabel} <path>\` first.`
+      };
+    }
+    const combined = sources.map((s) => s.content).join("\n\n---\n\n");
+    const truncated = combined.length > 32e3 ? combined.slice(0, 32e3) : combined;
+    this.logger.info(
+      { sampleCount: sources.length, totalChars: combined.length },
+      `Generating ${typeLabel} profile`
+    );
+    const chatResult = await this.ai.chat({
+      systemPrompt: `${systemPrompt}
+
+Do not include markdown fences, commentary, or any text outside the JSON object.`,
+      userPrompt: `Here are the ${typeLabel} samples:
+
+${truncated}`,
+      responseFormat: "json",
+      temperature: 0.3
+    });
+    if (!chatResult.ok) return { ok: false, error: chatResult.error };
+    const parsed = parseJsonRecord(chatResult.value);
+    if (!parsed.ok) return { ok: false, error: `Invalid JSON response for ${label}: ${parsed.error}` };
+    const schema = this.getSchema(type);
+    const validated = schema.safeParse(parsed.value);
+    if (!validated.success) {
+      this.logger.error({ error: validated.error.message }, `${label} AI response validation failed`);
+      return { ok: false, error: `Invalid AI response for ${label}: ${validated.error.message}` };
+    }
+    const profile = this.buildProfile(type, validated.data);
+    const saveResult = await this.saveProfile(type, profile);
+    if (!saveResult.ok) {
+      return { ok: false, error: saveResult.error };
+    }
+    const embedResult = await this.ai.generateEmbedding(JSON.stringify(validated.data));
+    if (embedResult.ok) {
+      const embResult = await this.profileRepo.saveProfileEmbedding(
+        profile.id,
+        type,
+        embedResult.value,
+        this.ai.getActiveEmbeddingModel()
+      );
+      if (!embResult.ok) {
+        this.logger.warn({ error: embResult.error }, "Embedding save failed for profile");
+      }
+    } else {
+      this.logger.warn({ error: embedResult.error }, "Embedding generation failed for profile");
+    }
+    this.logger.info({ profileId: profile.id }, `${label} generated`);
+    return { ok: true, value: profile };
+  }
+  getSchema(type) {
+    switch (type) {
+      case "voice":
+        return voiceProfileResponseSchema;
+      case "knowledge":
+        return knowledgeProfileResponseSchema;
+      case "publication":
+        return publicationProfileResponseSchema;
+    }
+  }
+  buildProfile(type, data) {
+    const id = randomUUID4();
+    const createdAt = /* @__PURE__ */ new Date();
+    switch (type) {
+      case "voice": {
+        const { traits, summary: summary2 } = voiceProfileResponseSchema.parse(data);
+        return { id, name: null, traits, summary: summary2, createdAt };
+      }
+      case "knowledge": {
+        const { domains, topics, summary: summary2 } = knowledgeProfileResponseSchema.parse(data);
+        return { id, domains, topics, summary: summary2, createdAt };
+      }
+      case "publication": {
+        const { themes, summary: summary2 } = publicationProfileResponseSchema.parse(data);
+        return { id, themes, series: null, summary: summary2, createdAt };
+      }
+    }
+  }
+  async saveProfile(type, profile) {
+    switch (type) {
+      case "voice":
+        return this.profileRepo.saveVoiceProfile(profile);
+      case "knowledge":
+        return this.profileRepo.saveKnowledgeProfile(profile);
+      case "publication":
+        return this.profileRepo.savePublicationProfile(profile);
+    }
+  }
+};
+
+// src/application/use-cases/import-sources.usecase.ts
+var DEFAULT_CONCURRENCY = 5;
+var ImportSourcesUseCase = class {
+  constructor(sourceRepo, fileSource, ai2, logger2) {
+    this.sourceRepo = sourceRepo;
+    this.fileSource = fileSource;
+    this.ai = ai2;
+    this.logger = logger2;
+  }
+  sourceRepo;
+  fileSource;
+  ai;
+  logger;
+  async execute(sourcePath, type) {
+    this.logger.info({ sourcePath, type }, "Starting import");
+    const sources = await this.fileSource.importFromPath(sourcePath, type);
+    const alreadyImportedResults = await Promise.all(
+      sources.map((s) => this.sourceRepo.isAlreadyImported(s.sourcePath, s.checksum))
+    );
+    const newSources = sources.filter((_, i) => {
+      const result = alreadyImportedResults[i];
+      return !result.ok || !result.value;
+    });
+    const skipped = sources.length - newSources.length;
+    if (skipped > 0) {
+      this.logger.info({ skipped }, "Skipped previously imported chunks");
+    }
+    if (newSources.length === 0) {
+      this.logger.info({ type }, "All sources already imported");
+      return { ok: true, value: 0 };
+    }
+    const saveResult = await this.sourceRepo.saveSources(newSources);
+    if (!saveResult.ok) {
+      this.logger.error({ error: saveResult.error }, "Failed to save sources");
+      return { ok: false, error: saveResult.error };
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const s of newSources) {
+      const key = `${s.sourcePath}:${s.checksum}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      await this.sourceRepo.logImport(s.sourcePath, s.checksum, type);
+    }
+    this.logger.info({ type, count: newSources.length, skipped }, "Import complete");
+    return { ok: true, value: newSources.length };
+  }
+  async generateEmbeddingsForType(type, onProgress) {
+    const sourcesResult = await this.sourceRepo.getSourcesByType(type);
+    if (!sourcesResult.ok) {
+      this.logger.error({ error: sourcesResult.error }, "Failed to load sources for embedding");
+      return { ok: false, error: sourcesResult.error };
+    }
+    const sources = sourcesResult.value;
+    const total = sources.length;
+    if (total === 0) {
+      onProgress?.(0, 0, "No sources to embed");
+      return { ok: true, value: { total: 0, failed: 0 } };
+    }
+    let completed = 0;
+    let failed = 0;
+    const model = this.ai.getActiveEmbeddingModel();
+    const processChunk = async (chunk) => {
+      const results = await Promise.allSettled(
+        chunk.map((source) => this.ai.generateEmbedding(source.content))
+      );
+      for (let j = 0; j < chunk.length; j++) {
+        const result = results[j];
+        if (result.status === "rejected") {
+          this.logger.warn({ sourceId: chunk[j].id }, "Embedding rejected");
+          failed++;
+          completed++;
+          continue;
+        }
+        if (!result.value.ok) {
+          this.logger.warn({ sourceId: chunk[j].id, error: result.value.error }, "Embedding failed");
+          failed++;
+          completed++;
+          continue;
+        }
+        const storeResult = await this.sourceRepo.saveSourceEmbedding(
+          chunk[j].id,
+          result.value.value,
+          model
+        );
+        if (!storeResult.ok) {
+          this.logger.warn({ sourceId: chunk[j].id, error: storeResult.error }, "Failed to store embedding");
+          failed++;
+        }
+        completed++;
+      }
+    };
+    onProgress?.(0, total, "Generating embeddings...");
+    for (let i = 0; i < sources.length; i += DEFAULT_CONCURRENCY) {
+      const chunk = sources.slice(i, i + DEFAULT_CONCURRENCY);
+      await processChunk(chunk);
+      onProgress?.(completed, total, `Embedded ${completed}/${total}`);
+    }
+    this.logger.info({ type, total: sources.length }, "Embeddings complete");
+    return { ok: true, value: { total, failed } };
+  }
+  async getImportStatus(type) {
+    const count = await this.sourceRepo.getSourceCountByType(type);
+    return count.ok ? count.value : 0;
+  }
+};
+
+// src/application/use-cases/export-article.usecase.ts
+import { marked } from "marked";
+var HTML_TEMPLATE = ({
+  title,
+  body,
+  createdAt,
+  wordCount
+}) => `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeHtml(title)}</title>
+<style>
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; font-size: 18px; line-height: 1.8; color: #1d1d1f; max-width: 720px; margin: 0 auto; padding: 2rem 1.5rem; }
+  header { margin-bottom: 2.5rem; }
+  h1 { font-size: 2rem; line-height: 1.3; margin-bottom: .5rem; }
+  .meta { color: #6e6e73; font-size: .875rem; }
+  h2 { font-size: 1.5rem; margin-top: 2rem; margin-bottom: .75rem; }
+  h3 { font-size: 1.25rem; margin-top: 1.5rem; margin-bottom: .5rem; }
+  p { margin-bottom: 1.25rem; }
+  a { color: #0066cc; }
+  code { background: #f5f5f7; padding: .15em .4em; border-radius: 3px; font-size: .9em; }
+  pre { background: #f5f5f7; padding: 1rem; border-radius: 8px; overflow-x: auto; margin-bottom: 1.25rem; }
+  pre code { background: none; padding: 0; }
+  blockquote { border-left: 3px solid #d2d2d7; padding-left: 1rem; color: #6e6e73; margin-bottom: 1.25rem; }
+  ul, ol { margin-bottom: 1.25rem; padding-left: 1.5rem; }
+  img { max-width: 100%; height: auto; border-radius: 8px; }
+  hr { border: none; border-top: 1px solid #d2d2d7; margin: 2rem 0; }
+  footer { margin-top: 3rem; padding-top: 1.5rem; border-top: 1px solid #d2d2d7; font-size: .8125rem; color: #6e6e73; }
+</style>
+</head>
+<body>
+<header>
+  <h1>${escapeHtml(title)}</h1>
+  <p class="meta">${createdAt} &middot; ${wordCount} words</p>
+</header>
+<main>${body}</main>
+<footer>Generated by Thoth</footer>
+</body>
+</html>`;
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function stripMarkdown(md) {
+  return md.replace(/#{1,6}\s+/g, "").replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/`(.+?)`/g, "$1").replace(/\[(.+?)\]\(.+?\)/g, "$1").replace(/!\[.*?\]\(.+?\)/g, "").replace(/>\s+/g, "").replace(/[-*+]\s+/g, "").replace(/\d+\.\s+/g, "").replace(/---/g, "").replace(/\n{3,}/g, "\n\n").trim();
+}
+function formatArticleAsMarkdown(article2) {
+  const date = article2.createdAt.toISOString().split("T")[0];
+  return [
+    "---",
+    `title: "${article2.title}"`,
+    `date: ${date}`,
+    `word_count: ${article2.wordCount}`,
+    `status: ${article2.status}`,
+    `id: ${article2.id}`,
+    "---",
+    "",
+    article2.content
+  ].join("\n");
+}
+function formatArticleAsHtml(article2) {
+  const date = article2.createdAt.toISOString().split("T")[0];
+  const body = marked.parse(article2.content);
+  return HTML_TEMPLATE({ title: article2.title, body, createdAt: date, wordCount: article2.wordCount });
+}
+function formatArticleAsTxt(article2) {
+  const date = article2.createdAt.toISOString().split("T")[0];
+  const plain = stripMarkdown(article2.content);
+  return [
+    `Title: ${article2.title}`,
+    `Date: ${date}`,
+    `Words: ${article2.wordCount}`,
+    `Status: ${article2.status}`,
+    "",
+    plain
+  ].join("\n");
+}
+var ExportArticleUseCase = class {
+  constructor(articleRepo) {
+    this.articleRepo = articleRepo;
+  }
+  articleRepo;
+  async execute(input) {
+    const articleResult = await this.articleRepo.get(input.articleId);
+    if (!articleResult.ok) return articleResult;
+    if (!articleResult.value) return { ok: false, error: `Article not found: ${input.articleId}` };
+    const article2 = articleResult.value;
+    const slug = article2.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "") || "article";
+    let content;
+    let ext;
+    switch (input.format) {
+      case "md":
+        content = formatArticleAsMarkdown(article2);
+        ext = "md";
+        break;
+      case "html":
+        content = formatArticleAsHtml(article2);
+        ext = "html";
+        break;
+      case "txt":
+        content = formatArticleAsTxt(article2);
+        ext = "txt";
+        break;
+    }
+    return {
+      ok: true,
+      value: { content, filename: `${slug}.${ext}` }
+    };
+  }
+};
+
+// src/application/use-cases/export-series.usecase.ts
+import { marked as marked2 } from "marked";
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function generateRssFeed(series, articles) {
+  const now = (/* @__PURE__ */ new Date()).toUTCString();
+  const items = articles.map(
+    (a) => `    <item>
+      <title>${escapeXml(a.title)}</title>
+      <guid isPermaLink="false">${escapeXml(a.id)}</guid>
+      <pubDate>${a.createdAt.toUTCString()}</pubDate>
+      <description>${escapeXml(stripMarkdown(a.content).slice(0, 500))}</description>
+      <content:encoded><![CDATA[${a.content}]]></content:encoded>
+    </item>`
+  ).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(series.name)}</title>
+    ${series.description ? `<description>${escapeXml(series.description)}</description>` : ""}
+    <link>https://thoth.sh</link>
+    <lastBuildDate>${now}</lastBuildDate>
+    <atom:link href="https://thoth.sh/rss.xml" rel="self" type="application/rss+xml"/>
+${items}
+  </channel>
+</rss>`;
+}
+function generateSeriesMarkdown(series, articles) {
+  const date = series.createdAt.toISOString().split("T")[0];
+  const parts = [
+    "---",
+    `title: "${series.name}"`,
+    `date: ${date}`,
+    `articles: ${articles.length}`,
+    `id: ${series.id}`,
+    "---",
+    "",
+    series.description ? `${series.description}
+` : ""
+  ];
+  for (let i = 0; i < articles.length; i++) {
+    const a = articles[i];
+    parts.push(`## ${i + 1}. ${a.title}`);
+    parts.push("");
+    parts.push(formatArticleAsMarkdown(a));
+    parts.push("");
+    parts.push("---");
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function generateSeriesHtml(series, articles) {
+  const date = series.createdAt.toISOString().split("T")[0];
+  const articleHtml = articles.map((a, i) => {
+    const body = marked2.parse(a.content);
+    return `<article>
+  <h2>${escapeXml(`${i + 1}. ${a.title}`)}</h2>
+  <div>${body}</div>
+</article>`;
+  }).join("\n");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>${escapeXml(series.name)}</title>
+<style>
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+  body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; font-size: 18px; line-height: 1.8; color: #1d1d1f; max-width: 720px; margin: 0 auto; padding: 2rem 1.5rem; }
+  h1 { font-size: 2rem; margin-bottom: .25rem; }
+  .meta { color: #6e6e73; font-size: .875rem; margin-bottom: 2rem; }
+  .toc { background: #f5f5f7; padding: 1.25rem 1.5rem; border-radius: 8px; margin-bottom: 2rem; }
+  .toc h2 { font-size: 1rem; margin-bottom: .5rem; }
+  .toc ol { padding-left: 1.25rem; }
+  .toc li { margin-bottom: .25rem; }
+  .toc a { color: #0066cc; text-decoration: none; }
+  .toc a:hover { text-decoration: underline; }
+  article { margin-bottom: 3rem; padding-top: 1rem; border-top: 1px solid #d2d2d7; }
+  article h2 { font-size: 1.5rem; margin-bottom: 1rem; }
+  article p { margin-bottom: 1.25rem; }
+  article a { color: #0066cc; }
+  article code { background: #f5f5f7; padding: .15em .4em; border-radius: 3px; font-size: .9em; }
+  article pre { background: #f5f5f7; padding: 1rem; border-radius: 8px; overflow-x: auto; margin-bottom: 1.25rem; }
+  article pre code { background: none; padding: 0; }
+  article blockquote { border-left: 3px solid #d2d2d7; padding-left: 1rem; color: #6e6e73; margin-bottom: 1.25rem; }
+  article ul, article ol { margin-bottom: 1.25rem; padding-left: 1.5rem; }
+  article img { max-width: 100%; height: auto; border-radius: 8px; }
+  footer { margin-top: 2rem; padding-top: 1.5rem; border-top: 1px solid #d2d2d7; font-size: .8125rem; color: #6e6e73; }
+</style>
+</head>
+<body>
+<header>
+  <h1>${escapeXml(series.name)}</h1>
+  ${series.description ? `<p class="meta">${escapeXml(series.description)}</p>` : ""}
+  <p class="meta">${articles.length} articles &middot; ${date}</p>
+</header>
+<nav class="toc">
+  <h2>Table of Contents</h2>
+  <ol>
+    ${articles.map((a, i) => `<li><a href="#article-${i + 1}">${escapeXml(a.title)}</a></li>`).join("\n    ")}
+  </ol>
+</nav>
+<main>
+${articleHtml}
+</main>
+<footer>Generated by Thoth</footer>
+</body>
+</html>`;
+}
+var ExportSeriesUseCase = class {
+  constructor(seriesRepo, articleRepo) {
+    this.seriesRepo = seriesRepo;
+    this.articleRepo = articleRepo;
+  }
+  seriesRepo;
+  articleRepo;
+  async execute(input) {
+    const seriesResult = await this.seriesRepo.get(input.seriesId);
+    if (!seriesResult.ok) return seriesResult;
+    if (!seriesResult.value) return { ok: false, error: `Series not found: ${input.seriesId}` };
+    const series = seriesResult.value;
+    const articles = [];
+    for (const articleId of series.articleIds) {
+      const articleResult = await this.articleRepo.get(articleId);
+      if (articleResult.ok && articleResult.value) {
+        articles.push(articleResult.value);
+      }
+    }
+    const slug = series.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "") || "series";
+    let content;
+    let ext;
+    switch (input.format) {
+      case "md":
+        content = generateSeriesMarkdown(series, articles);
+        ext = "md";
+        break;
+      case "html":
+        content = generateSeriesHtml(series, articles);
+        ext = "html";
+        break;
+      case "rss":
+        content = generateRssFeed(series, articles);
+        ext = "xml";
+        break;
+    }
+    return {
+      ok: true,
+      value: { content, filename: `${slug}.${ext}` }
+    };
+  }
+};
+
+// src/application/use-cases/series.usecase.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var SeriesUseCase = class {
+  constructor(seriesRepo, logger2) {
+    this.seriesRepo = seriesRepo;
+    this.logger = logger2;
+  }
+  seriesRepo;
+  logger;
+  async create(name, description) {
+    const series = {
+      id: randomUUID5(),
+      name,
+      description: description ?? null,
+      articleIds: [],
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const result = await this.seriesRepo.save(series);
+    if (!result.ok) return result;
+    this.logger.info({ seriesId: series.id, name }, "Series created");
+    return { ok: true, value: series };
+  }
+  async list() {
+    return this.seriesRepo.list();
+  }
+  async get(id) {
+    return this.seriesRepo.get(id);
+  }
+  async addArticle(seriesId, articleId) {
+    const seriesResult = await this.seriesRepo.get(seriesId);
+    if (!seriesResult.ok) return { ok: false, error: seriesResult.error };
+    if (!seriesResult.value) return { ok: false, error: `Series not found: ${seriesId}` };
+    const result = await this.seriesRepo.addArticle(seriesId, articleId);
+    if (!result.ok) return result;
+    this.logger.info({ seriesId, articleId }, "Article added to series");
+    return { ok: true, value: void 0 };
+  }
+};
+
+// src/application/use-cases/publish-article.usecase.ts
+var PublishArticleUseCase = class {
+  constructor(articleRepository, mediumAdapter, logger2) {
+    this.articleRepository = articleRepository;
+    this.mediumAdapter = mediumAdapter;
+    this.logger = logger2;
+  }
+  articleRepository;
+  mediumAdapter;
+  logger;
+  async execute(articleId) {
+    const articleResult = await this.articleRepository.get(articleId);
+    if (!articleResult.ok) return articleResult;
+    if (!articleResult.value) {
+      return { ok: false, error: `Article not found: ${articleId}` };
+    }
+    const article2 = articleResult.value;
+    this.logger.info(
+      { articleId, title: article2.title },
+      "Publishing article to Medium..."
+    );
+    const publishResult = await this.mediumAdapter.publish({
+      title: article2.title,
+      content: article2.content
+    });
+    if (!publishResult.ok) return publishResult;
+    const { mediumUrl } = publishResult.value;
+    const updatedArticle = {
+      ...article2,
+      mediumUrl,
+      status: "published",
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.logger.info({ articleId, mediumUrl }, "Article published to Medium.");
+    return this.articleRepository.save(updatedArticle);
+  }
+};
+
+// src/infrastructure/publishing/medium-http.adapter.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var SESSION_DIR = join4(homedir4(), ".thoth");
+var CREDENTIALS_FILE = join4(SESSION_DIR, "medium-credentials.json");
+var MediumHttpAdapter = class {
+  constructor(logger2) {
+    this.logger = logger2;
+  }
+  logger;
+  connect(params) {
+    if (!existsSync2(SESSION_DIR)) {
+      mkdirSync2(SESSION_DIR, { recursive: true });
+    }
+    const credentials = {
+      sid: params.sid.trim(),
+      uid: params.uid.trim()
+    };
+    writeFileSync(CREDENTIALS_FILE, JSON.stringify(credentials), { mode: 384 });
+    this.logger.info({ action: "connect_medium_saved" }, "Medium credentials saved.");
+    return Promise.resolve({ ok: true, value: void 0 });
+  }
+  isAuthenticated() {
+    if (!existsSync2(CREDENTIALS_FILE)) return Promise.resolve(false);
+    try {
+      const raw = readFileSync3(CREDENTIALS_FILE, "utf-8");
+      const creds = JSON.parse(raw);
+      return Promise.resolve(typeof creds.sid === "string" && typeof creds.uid === "string");
+    } catch {
+      return Promise.resolve(false);
+    }
+  }
+  async publish(params) {
+    if (!existsSync2(CREDENTIALS_FILE)) {
+      return {
+        ok: false,
+        error: "Not authenticated. Run `thoth connect medium` first."
+      };
+    }
+    let credentials;
+    try {
+      credentials = JSON.parse(readFileSync3(CREDENTIALS_FILE, "utf-8"));
+    } catch {
+      return { ok: false, error: "Credentials file is corrupted. Run `thoth connect medium` again." };
+    }
+    const cookie = `uid=${credentials.uid}; sid=${credentials.sid}`;
+    try {
+      this.logger.info({ action: "publish" }, "Creating Medium draft via API...");
+      const response = await fetch("https://medium.com/_/api/posts", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Cookie: cookie,
+          Accept: "application/json"
+        },
+        body: JSON.stringify({
+          title: params.title,
+          content: params.content,
+          contentFormat: "markdown",
+          publishStatus: "draft",
+          tags: []
+        })
+      });
+      if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        this.logger.error(
+          { status: response.status, body: text.slice(0, 500) },
+          "Medium API returned error"
+        );
+        return {
+          ok: false,
+          error: response.status === 401 || response.status === 403 ? "Medium rejected the credentials. Your session may have expired. Run `thoth connect medium` again." : `Medium API error (${response.status}). The API may have changed.`
+        };
+      }
+      const body = await response.json();
+      const payload = body.payload;
+      const mediumPostId = payload?.id ?? "";
+      const mediumUrl = mediumPostId ? `https://medium.com/p/${mediumPostId}` : "https://medium.com/me/stories";
+      const result = { mediumPostId, mediumUrl };
+      this.logger.info({ action: "publish_success", mediumUrl }, "Draft created on Medium.");
+      return { ok: true, value: result };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { ok: false, error: `Publish failed: ${message}` };
+    }
+  }
+};
+
+// src/infrastructure/persistence/repositories/sqlite-research-repository.ts
+import { z as z3 } from "zod";
+var researchNoteRowSchema = z3.object({
+  id: z3.string(),
+  topic: z3.string(),
+  content: z3.string(),
+  citations: z3.string(),
+  created_at: z3.string()
+}).transform((row) => ({
+  id: row.id,
+  topic: row.topic,
+  content: row.content,
+  citations: JSON.parse(row.citations),
+  createdAt: new Date(row.created_at)
+}));
+var SqliteResearchRepository = class {
+  constructor(db3, embeddingTableSuffix = "openai") {
+    this.db = db3;
+    this.vecTable = `vec_research_${embeddingTableSuffix}`;
+  }
+  db;
+  vecTable;
+  save(note) {
+    this.db.prepare(
+      `INSERT INTO research_notes (id, topic, content, citations, created_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           topic = excluded.topic,
+           content = excluded.content,
+           citations = excluded.citations`
+    ).run(
+      note.id,
+      note.topic,
+      note.content,
+      JSON.stringify(note.citations),
+      note.createdAt.toISOString()
+    );
+    return Promise.resolve({ ok: true, value: note });
+  }
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM research_notes WHERE id = ?").get(id);
+    if (!row) return Promise.resolve({ ok: true, value: null });
+    const parsed = researchNoteRowSchema.safeParse(row);
+    if (!parsed.success) return Promise.resolve({ ok: false, error: `Invalid research note row: ${parsed.error.message}` });
+    return Promise.resolve({ ok: true, value: parsed.data });
+  }
+  searchByTopic(topic) {
+    const rows = this.db.prepare("SELECT * FROM research_notes WHERE topic LIKE ? ORDER BY created_at DESC").all(`%${topic}%`);
+    const notes = [];
+    for (const row of rows) {
+      const parsed = researchNoteRowSchema.safeParse(row);
+      if (!parsed.success) continue;
+      notes.push(parsed.data);
+    }
+    return Promise.resolve({ ok: true, value: notes });
+  }
+  saveResearchEmbedding(researchId, embedding, model) {
+    try {
+      const insertVec = this.db.prepare(`INSERT INTO ${this.vecTable} (embedding) VALUES (?)`);
+      const insertEmb = this.db.prepare(
+        "INSERT INTO research_embeddings (research_id, model) VALUES (?, ?)"
+      );
+      const doInsert = this.db.transaction(() => {
+        insertVec.run(new Float32Array(embedding));
+        insertEmb.run(researchId, model);
+      });
+      doInsert();
+      return Promise.resolve({ ok: true, value: void 0 });
+    } catch (error2) {
+      return Promise.resolve({
+        ok: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
+  }
+};
+
+// src/infrastructure/persistence/repositories/sqlite-article-repository.ts
+import { z as z4 } from "zod";
+var articleRowSchema = z4.object({
+  id: z4.string(),
+  title: z4.string(),
+  content: z4.string(),
+  voice_profile_id: z4.string(),
+  research_id: z4.string().nullable(),
+  word_count: z4.number(),
+  status: z4.enum(["draft", "published", "archived"]),
+  medium_url: z4.string().nullable(),
+  created_at: z4.string(),
+  updated_at: z4.string()
+}).transform((row) => ({
+  id: row.id,
+  title: row.title,
+  content: row.content,
+  voiceProfileId: row.voice_profile_id,
+  researchId: row.research_id,
+  wordCount: row.word_count,
+  status: row.status,
+  mediumUrl: row.medium_url,
+  createdAt: new Date(row.created_at),
+  updatedAt: new Date(row.updated_at)
+}));
+var SqliteArticleRepository = class {
+  constructor(db3) {
+    this.db = db3;
+  }
+  db;
+  save(article2) {
+    this.db.prepare(
+      `INSERT INTO articles (id, title, content, voice_profile_id, research_id, word_count, status, medium_url, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           title = excluded.title,
+           content = excluded.content,
+           word_count = excluded.word_count,
+           status = excluded.status,
+           medium_url = excluded.medium_url,
+           updated_at = excluded.updated_at`
+    ).run(
+      article2.id,
+      article2.title,
+      article2.content,
+      article2.voiceProfileId,
+      article2.researchId,
+      article2.wordCount,
+      article2.status,
+      article2.mediumUrl,
+      article2.createdAt.toISOString(),
+      article2.updatedAt.toISOString()
+    );
+    return Promise.resolve({ ok: true, value: article2 });
+  }
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM articles WHERE id = ?").get(id);
+    if (!row) return Promise.resolve({ ok: true, value: null });
+    const parsed = articleRowSchema.safeParse(row);
+    if (!parsed.success) return Promise.resolve({ ok: false, error: `Invalid article row: ${parsed.error.message}` });
+    return Promise.resolve({ ok: true, value: parsed.data });
+  }
+  list() {
+    const rows = this.db.prepare("SELECT * FROM articles ORDER BY created_at DESC").all();
+    const articles = [];
+    for (const row of rows) {
+      const parsed = articleRowSchema.safeParse(row);
+      if (!parsed.success) continue;
+      articles.push(parsed.data);
+    }
+    return Promise.resolve({ ok: true, value: articles });
+  }
+};
+
+// src/infrastructure/persistence/repositories/profile-schemas.ts
+import { z as z5 } from "zod";
+var voiceProfileRowSchema = z5.object({
+  id: z5.string(),
+  name: z5.string().nullable(),
+  traits: z5.string(),
+  summary: z5.string().nullable(),
+  created_at: z5.string()
+}).transform((row) => ({
+  id: row.id,
+  name: row.name,
+  traits: JSON.parse(row.traits),
+  summary: row.summary,
+  createdAt: new Date(row.created_at)
+}));
+var knowledgeProfileRowSchema = z5.object({
+  id: z5.string(),
+  domains: z5.string(),
+  topics: z5.string(),
+  summary: z5.string().nullable(),
+  created_at: z5.string()
+}).transform((row) => ({
+  id: row.id,
+  domains: JSON.parse(row.domains),
+  topics: JSON.parse(row.topics),
+  summary: row.summary,
+  createdAt: new Date(row.created_at)
+}));
+var publicationProfileRowSchema = z5.object({
+  id: z5.string(),
+  themes: z5.string(),
+  series: z5.string().nullable(),
+  summary: z5.string().nullable(),
+  created_at: z5.string()
+}).transform((row) => ({
+  id: row.id,
+  themes: JSON.parse(row.themes),
+  series: row.series ? JSON.parse(row.series) : null,
+  summary: row.summary,
+  createdAt: new Date(row.created_at)
+}));
+
+// src/infrastructure/persistence/repositories/sqlite-profile-repository.ts
+function parseRow(schema, row, label) {
+  try {
+    return { ok: true, value: schema.parse(row) };
+  } catch (error2) {
+    return { ok: false, error: `Invalid ${label} row: ${error2 instanceof Error ? error2.message : String(error2)}` };
+  }
+}
+var SqliteProfileRepository = class {
+  constructor(db3, embeddingTableSuffix = "openai") {
+    this.db = db3;
+    this.vecTable = `vec_profiles_${embeddingTableSuffix}`;
+  }
+  db;
+  vecTable;
+  saveVoiceProfile(profile) {
+    return Promise.resolve(this.saveVoiceProfileSync(profile));
+  }
+  getVoiceProfile(id) {
+    return Promise.resolve(this.getProfileByTypeAndId("voice", id));
+  }
+  getLatestVoiceProfile() {
+    return Promise.resolve(this.getLatestProfileByType("voice"));
+  }
+  saveKnowledgeProfile(profile) {
+    return Promise.resolve(this.saveKnowledgeProfileSync(profile));
+  }
+  getKnowledgeProfile(id) {
+    return Promise.resolve(this.getProfileByTypeAndId("knowledge", id));
+  }
+  getLatestKnowledgeProfile() {
+    return Promise.resolve(this.getLatestProfileByType("knowledge"));
+  }
+  savePublicationProfile(profile) {
+    return Promise.resolve(this.savePublicationProfileSync(profile));
+  }
+  getPublicationProfile(id) {
+    return Promise.resolve(this.getProfileByTypeAndId("publication", id));
+  }
+  getLatestPublicationProfile() {
+    return Promise.resolve(this.getLatestProfileByType("publication"));
+  }
+  saveProfileEmbedding(profileId, type, embedding, model) {
+    try {
+      const insertEmb = this.db.prepare(
+        "INSERT INTO profile_embeddings (profile_id, profile_type, model) VALUES (?, ?, ?)"
+      );
+      const insertVec = this.db.prepare(`INSERT INTO ${this.vecTable} (embedding) VALUES (?)`);
+      const doInsert = this.db.transaction(() => {
+        insertVec.run(new Float32Array(embedding));
+        insertEmb.run(profileId, type, model);
+      });
+      doInsert();
+      return Promise.resolve({ ok: true, value: void 0 });
+    } catch (error2) {
+      return Promise.resolve({
+        ok: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
+  }
+  saveVoiceProfileSync(profile) {
+    this.db.prepare(
+      `INSERT INTO voice_profiles (id, name, traits, summary, created_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name,
+           traits = excluded.traits,
+           summary = excluded.summary`
+    ).run(
+      profile.id,
+      profile.name,
+      JSON.stringify(profile.traits),
+      profile.summary,
+      profile.createdAt.toISOString()
+    );
+    return { ok: true, value: profile };
+  }
+  saveKnowledgeProfileSync(profile) {
+    this.db.prepare(
+      `INSERT INTO knowledge_profiles (id, domains, topics, summary, created_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           domains = excluded.domains,
+           topics = excluded.topics,
+           summary = excluded.summary`
+    ).run(
+      profile.id,
+      JSON.stringify(profile.domains),
+      JSON.stringify(profile.topics),
+      profile.summary,
+      profile.createdAt.toISOString()
+    );
+    return { ok: true, value: profile };
+  }
+  savePublicationProfileSync(profile) {
+    this.db.prepare(
+      `INSERT INTO publication_profiles (id, themes, series, summary, created_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           themes = excluded.themes,
+           series = excluded.series,
+           summary = excluded.summary`
+    ).run(
+      profile.id,
+      JSON.stringify(profile.themes),
+      profile.series ? JSON.stringify(profile.series) : null,
+      profile.summary,
+      profile.createdAt.toISOString()
+    );
+    return { ok: true, value: profile };
+  }
+  getProfileByTypeAndId(type, id) {
+    const table = this.tableForType(type);
+    const row = this.db.prepare(`SELECT * FROM ${table} WHERE id = ?`).get(id);
+    if (!row) return { ok: true, value: null };
+    const schema = this.schemaForType(type);
+    return parseRow(schema, row, `${type} profile`);
+  }
+  getLatestProfileByType(type) {
+    const table = this.tableForType(type);
+    const row = this.db.prepare(`SELECT * FROM ${table} ORDER BY created_at DESC LIMIT 1`).get();
+    if (!row) return { ok: true, value: null };
+    const schema = this.schemaForType(type);
+    return parseRow(schema, row, `${type} profile`);
+  }
+  getProfileStatus() {
+    try {
+      const voiceRow = this.db.prepare("SELECT id, summary FROM voice_profiles ORDER BY created_at DESC LIMIT 1").get();
+      const knowledgeRow = this.db.prepare("SELECT id, domains FROM knowledge_profiles ORDER BY created_at DESC LIMIT 1").get();
+      const pubRow = this.db.prepare("SELECT id, themes FROM publication_profiles ORDER BY created_at DESC LIMIT 1").get();
+      return Promise.resolve({
+        ok: true,
+        value: {
+          voice: voiceRow ? { exists: true, id: voiceRow.id, summary: voiceRow.summary } : { exists: false },
+          knowledge: knowledgeRow ? { exists: true, id: knowledgeRow.id, domains: knowledgeRow.domains } : { exists: false },
+          publication: pubRow ? { exists: true, id: pubRow.id, themes: pubRow.themes } : { exists: false }
+        }
+      });
+    } catch (error2) {
+      return Promise.resolve({
+        ok: false,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
+  }
+  tableForType(type) {
+    switch (type) {
+      case "voice":
+        return "voice_profiles";
+      case "knowledge":
+        return "knowledge_profiles";
+      case "publication":
+        return "publication_profiles";
+    }
+  }
+  schemaForType(type) {
+    switch (type) {
+      case "voice":
+        return voiceProfileRowSchema;
+      case "knowledge":
+        return knowledgeProfileRowSchema;
+      case "publication":
+        return publicationProfileRowSchema;
+    }
+  }
+};
+
+// src/infrastructure/persistence/repositories/source-schemas.ts
+import { z as z6 } from "zod";
+var sourceReferenceSchema = z6.object({
+  id: z6.string(),
+  type: z6.enum(["voice", "knowledge", "publication"]),
+  source_path: z6.string(),
+  content: z6.string(),
+  checksum: z6.string(),
+  chunk_index: z6.number(),
+  created_at: z6.string()
+}).transform((row) => ({
+  id: row.id,
+  type: row.type,
+  sourcePath: row.source_path,
+  content: row.content,
+  checksum: row.checksum,
+  chunkIndex: row.chunk_index,
+  createdAt: new Date(row.created_at)
+}));
+
+// src/infrastructure/persistence/repositories/source-repository.ts
+function saveSources(db3, sources) {
+  const insert = db3.prepare(
+    `INSERT OR IGNORE INTO sources (id, type, source_path, content, checksum, chunk_index, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  );
+  const insertMany = db3.transaction((items) => {
+    for (const s of items) {
+      insert.run(
+        s.id,
+        s.type,
+        s.sourcePath,
+        s.content,
+        s.checksum,
+        s.chunkIndex,
+        s.createdAt.toISOString()
+      );
+    }
+  });
+  insertMany(sources);
+}
+function getSourcesByType(db3, type) {
+  const rows = db3.prepare("SELECT * FROM sources WHERE type = ? ORDER BY created_at").all(type);
+  const mapped = [];
+  for (const row of rows) {
+    const parsed = sourceReferenceSchema.safeParse(row);
+    if (!parsed.success) {
+      return { ok: false, error: `Invalid source row: ${parsed.error.message}` };
+    }
+    mapped.push(parsed.data);
+  }
+  return { ok: true, value: mapped };
+}
+function getSourceCountByType(db3, type) {
+  const row = db3.prepare("SELECT COUNT(*) as count FROM sources WHERE type = ?").get(type);
+  return row.count;
+}
+
+// src/infrastructure/persistence/repositories/sqlite-source-repository.ts
+var SqliteSourceRepository = class {
+  constructor(db3, embeddingTableSuffix = "openai") {
+    this.db = db3;
+    this.vecTable = `vec_sources_${embeddingTableSuffix}`;
+  }
+  db;
+  vecTable;
+  saveSources(sources) {
+    saveSources(this.db, sources);
+    return Promise.resolve({ ok: true, value: void 0 });
+  }
+  getSourcesByType(type) {
+    return Promise.resolve(getSourcesByType(this.db, type));
+  }
+  getSourceCountByType(type) {
+    return Promise.resolve({ ok: true, value: getSourceCountByType(this.db, type) });
+  }
+  searchByVector(embedding, k) {
+    try {
+      const rows = this.db.prepare(
+        `SELECT v.rowid, s.id, s.source_path, s.content, v.distance
+           FROM ${this.vecTable} v
+           JOIN sources s ON v.rowid = s.rowid
+           WHERE v.embedding MATCH ? AND k = ?
+           ORDER BY v.distance`
+      ).all(new Float32Array(embedding), k);
+      const results = rows.map((r) => ({
+        id: r.id,
+        sourcePath: r.source_path,
+        content: r.content,
+        distance: r.distance
+      }));
+      return Promise.resolve({ ok: true, value: results });
+    } catch (error2) {
+      return Promise.resolve({ ok: false, error: error2 instanceof Error ? error2.message : String(error2) });
+    }
+  }
+  isAlreadyImported(sourcePath, checksum) {
+    try {
+      const row = this.db.prepare("SELECT 1 FROM import_log WHERE source_path = ? AND checksum = ?").get(sourcePath, checksum);
+      return Promise.resolve({ ok: true, value: !!row });
+    } catch {
+      return Promise.resolve({ ok: true, value: false });
+    }
+  }
+  logImport(sourcePath, checksum, type) {
+    try {
+      this.db.prepare("INSERT OR IGNORE INTO import_log (source_path, checksum, type) VALUES (?, ?, ?)").run(sourcePath, checksum, type);
+      return Promise.resolve({ ok: true, value: void 0 });
+    } catch (error2) {
+      return Promise.resolve({
+        ok: false,
+        error: `Failed to log import: ${error2 instanceof Error ? error2.message : String(error2)}`
+      });
+    }
+  }
+  saveSourceEmbedding(sourceId, embedding, model) {
+    try {
+      const insertVec = this.db.prepare(`INSERT INTO ${this.vecTable} (embedding) VALUES (?)`);
+      const insertEmb = this.db.prepare(
+        "INSERT INTO source_embeddings (source_id, model) VALUES (?, ?)"
+      );
+      const doInsert = this.db.transaction(() => {
+        insertVec.run(new Float32Array(embedding));
+        insertEmb.run(sourceId, model);
+      });
+      doInsert();
+      return Promise.resolve({ ok: true, value: void 0 });
+    } catch (error2) {
+      return Promise.resolve({ ok: false, error: error2 instanceof Error ? error2.message : String(error2) });
+    }
+  }
+};
+
+// src/infrastructure/persistence/repositories/sqlite-series-repository.ts
+import { z as z7 } from "zod";
+var seriesRowSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  description: z7.string().nullable(),
+  created_at: z7.string(),
+  updated_at: z7.string()
+}).transform((row) => ({
+  id: row.id,
+  name: row.name,
+  description: row.description,
+  articleIds: [],
+  createdAt: new Date(row.created_at),
+  updatedAt: new Date(row.updated_at)
+}));
+var SqliteSeriesRepository = class {
+  constructor(db3) {
+    this.db = db3;
+  }
+  db;
+  save(series) {
+    this.db.prepare(
+      `INSERT INTO series (id, name, description, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(id) DO UPDATE SET
+           name = excluded.name,
+           description = excluded.description,
+           updated_at = excluded.updated_at`
+    ).run(
+      series.id,
+      series.name,
+      series.description,
+      series.createdAt.toISOString(),
+      series.updatedAt.toISOString()
+    );
+    return Promise.resolve({ ok: true, value: series });
+  }
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM series WHERE id = ?").get(id);
+    if (!row) return Promise.resolve({ ok: true, value: null });
+    const parsed = seriesRowSchema.safeParse(row);
+    if (!parsed.success) return Promise.resolve({ ok: false, error: `Invalid series row: ${parsed.error.message}` });
+    const articleRows = this.db.prepare("SELECT article_id FROM series_articles WHERE series_id = ? ORDER BY position").all(id);
+    return Promise.resolve({
+      ok: true,
+      value: { ...parsed.data, articleIds: articleRows.map((r) => r.article_id) }
+    });
+  }
+  list() {
+    const rows = this.db.prepare("SELECT * FROM series ORDER BY created_at DESC").all();
+    const seriesList = [];
+    for (const row of rows) {
+      const parsed = seriesRowSchema.safeParse(row);
+      if (!parsed.success) continue;
+      const articleRows = this.db.prepare("SELECT article_id FROM series_articles WHERE series_id = ? ORDER BY position").all(parsed.data.id);
+      seriesList.push({ ...parsed.data, articleIds: articleRows.map((r) => r.article_id) });
+    }
+    return Promise.resolve({ ok: true, value: seriesList });
+  }
+  addArticle(seriesId, articleId) {
+    const maxPos = this.db.prepare("SELECT COALESCE(MAX(position), -1) + 1 as next_pos FROM series_articles WHERE series_id = ?").get(seriesId);
+    this.db.prepare(
+      "INSERT OR IGNORE INTO series_articles (series_id, article_id, position) VALUES (?, ?, ?)"
+    ).run(seriesId, articleId, maxPos.next_pos);
+    this.db.prepare(
+      "UPDATE series SET updated_at = ? WHERE id = ?"
+    ).run((/* @__PURE__ */ new Date()).toISOString(), seriesId);
+    return Promise.resolve({ ok: true, value: void 0 });
+  }
+  removeArticle(seriesId, articleId) {
+    this.db.prepare("DELETE FROM series_articles WHERE series_id = ? AND article_id = ?").run(seriesId, articleId);
+    this.db.prepare(
+      "UPDATE series SET updated_at = ? WHERE id = ?"
+    ).run((/* @__PURE__ */ new Date()).toISOString(), seriesId);
+    return Promise.resolve({ ok: true, value: void 0 });
+  }
+};
+
+// src/infrastructure/composition-root.ts
+function providerKey() {
+  return getActiveEmbeddingProviderKey();
+}
+function db2() {
+  return getDatabase();
+}
+function ai() {
+  return new OpenAiAiService();
+}
+function createResearchUseCase() {
+  const key = providerKey();
+  return new ResearchUseCase(
+    ai(),
+    new SqliteResearchRepository(db2(), key),
+    new SqliteSourceRepository(db2(), key),
+    logger
+  );
+}
+function createGenerateArticleUseCase() {
+  return new GenerateArticleUseCase(
+    ai(),
+    new SqliteArticleRepository(db2()),
+    new SqliteProfileRepository(db2()),
+    new SqliteResearchRepository(db2()),
+    logger
+  );
+}
+function createGenerateProfilesUseCase() {
+  const key = providerKey();
+  return new GenerateProfilesUseCase(
+    ai(),
+    new SqliteProfileRepository(db2(), key),
+    new SqliteSourceRepository(db2(), key),
+    logger
+  );
+}
+function createImportSourcesUseCase() {
+  const key = providerKey();
+  return new ImportSourcesUseCase(
+    new SqliteSourceRepository(db2(), key),
+    new FileSourceAdapter(),
+    ai(),
+    logger
+  );
+}
+function createExportArticleUseCase() {
+  return new ExportArticleUseCase(new SqliteArticleRepository(db2()));
+}
+function createExportSeriesUseCase() {
+  return new ExportSeriesUseCase(
+    new SqliteSeriesRepository(db2()),
+    new SqliteArticleRepository(db2())
+  );
+}
+function createSeriesUseCase() {
+  return new SeriesUseCase(new SqliteSeriesRepository(db2()), logger);
+}
+function createArticleRepository() {
+  return new SqliteArticleRepository(db2());
+}
+function createProfileRepository() {
+  const key = providerKey();
+  return new SqliteProfileRepository(db2(), key);
+}
+function createSourceRepository() {
+  const key = providerKey();
+  return new SqliteSourceRepository(db2(), key);
+}
+function createPublishArticleUseCase() {
+  return new PublishArticleUseCase(
+    new SqliteArticleRepository(db2()),
+    new MediumHttpAdapter(logger),
+    logger
+  );
+}
+function createMediumAdapter() {
+  return new MediumHttpAdapter(logger);
+}
+
+// src/cli/ui.ts
+import ora from "ora";
+var useColor = process.stderr.isTTY && process.env.NO_COLOR === void 0;
+var codes = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  gray: "\x1B[90m"
+};
+function paint(value, color2) {
+  if (!useColor) return value;
+  return `${codes[color2]}${value}${codes.reset}`;
+}
+function bold(value) {
+  if (!useColor) return value;
+  return `${codes.bold}${value}${codes.reset}`;
+}
+var color = {
+  cyan: (value) => paint(value, "cyan"),
+  green: (value) => paint(value, "green"),
+  yellow: (value) => paint(value, "yellow"),
+  red: (value) => paint(value, "red"),
+  blue: (value) => paint(value, "blue"),
+  magenta: (value) => paint(value, "magenta"),
+  gray: (value) => paint(value, "gray"),
+  dim: (value) => paint(value, "dim"),
+  bold
+};
+function writeStderr(value) {
+  process.stderr.write(value + "\n");
+}
+function blank() {
+  writeStderr("");
+}
+function heading(value) {
+  writeStderr(color.cyan(color.bold(value)));
+}
+function section(value) {
+  writeStderr(color.blue(color.bold(value)));
+}
+function step(value) {
+  writeStderr(`${color.cyan(">")} ${value}`);
+}
+function success(value) {
+  writeStderr(`${color.green("[ok]")} ${value}`);
+}
+function warn(value) {
+  writeStderr(`${color.yellow("[warn]")} ${value}`);
+}
+function error(value) {
+  writeStderr(`${color.red("[error]")} ${value}`);
+}
+function info(value) {
+  writeStderr(`${color.blue("[info]")} ${value}`);
+}
+function empty(value) {
+  writeStderr(color.dim(value));
+}
+function meta(label, value) {
+  writeStderr(`  ${color.gray(label.padEnd(16))} ${value}`);
+}
+function item(id, value) {
+  writeStderr(`  ${color.gray(id)}  ${value}`);
+}
+function divider() {
+  writeStderr(color.dim("\u2500".repeat(48)));
+}
+function output(value) {
+  process.stdout.write(value + "\n");
+}
+function article(value) {
+  writeStderr(value);
+}
+function timer(start) {
+  const elapsed = process.hrtime(start);
+  const ms = elapsed[0] * 1e3 + elapsed[1] / 1e6;
+  if (ms < 1e3) return `${ms.toFixed(1)}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const min = Math.floor(ms / 6e4);
+  const sec = (ms % 6e4 / 1e3).toFixed(0);
+  return `${min}m ${sec}s`;
+}
+function spinner(initialText) {
+  let instance = null;
+  return {
+    start(text) {
+      if (!instance) {
+        instance = ora({ text: text ?? initialText, color: "cyan" }).start();
+      }
+    },
+    stop(finalText) {
+      if (instance) {
+        instance.stop();
+        if (finalText) writeStderr(`  ${color.green(finalText)}`);
+        instance = null;
+      }
+    },
+    setText(text) {
+      if (instance) instance.text = text;
+    },
+    get isSpinning() {
+      return instance !== null;
+    }
+  };
+}
+function summary(entries) {
+  const keys = Object.keys(entries);
+  const labelWidth = Math.max(...keys.map((k) => k.length));
+  writeStderr(color.bold(color.cyan("Summary")));
+  for (const [label, value] of Object.entries(entries)) {
+    writeStderr(`  ${color.gray(label.padEnd(labelWidth + 2))} ${value}`);
+  }
+}
+function nextSteps(steps) {
+  section("Next steps");
+  for (const command of steps) {
+    writeStderr(`  ${color.magenta(command)}`);
+  }
+}
+
+// src/cli/error-handler.ts
+async function withCliError(logger2, label, fn) {
+  try {
+    return await fn();
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    logger2.error({ error: message }, `${label} failed`);
+    error(`${label} failed: ${message}`);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/article.command.ts
+function registerArticleCommand(program2) {
+  program2.command("generate_article").description("Generate an article using your voice profile (--topic, --research)").option("-t, --topic <topic>", "Topic to write about").option("-r, --research <id>", "Research note ID to use as source").action(async (options) => {
+    await withCliError(logger, "Article generation", async () => {
+      if (!options.topic && !options.research) {
+        error("Provide a topic (--topic) or research ID (--research).");
+        process.exit(1);
+      }
+      if (options.topic && options.topic.length > 500) {
+        error("Topic must be under 500 characters.");
+        process.exit(1);
+      }
+      const useCase = createGenerateArticleUseCase();
+      heading("Generating article");
+      if (options.topic) meta("Topic", options.topic);
+      if (options.research) meta("Research ID", options.research);
+      blank();
+      const spin = spinner("Drafting article...");
+      const startTime = process.hrtime();
+      spin.start();
+      const result = await useCase.execute({
+        topic: options.topic,
+        researchId: options.research
+      });
+      spin.stop();
+      const duration = timer(startTime);
+      if (!result.ok) {
+        error(`Generation failed: ${result.error}`);
+        process.exit(1);
+      }
+      success("Article generated.");
+      meta("Title", result.value.title);
+      meta("Words", result.value.wordCount);
+      meta("ID", result.value.id);
+      meta("Duration", duration);
+      blank();
+      divider();
+      output(result.value.content);
+      divider();
+      closeDatabase();
+    });
+  });
+  program2.command("list_articles").description("List generated articles").action(async () => {
+    await withCliError(logger, "Article list", async () => {
+      const repo = createArticleRepository();
+      const result = await repo.list();
+      if (!result.ok) {
+        error(`Failed to list articles: ${result.error}`);
+        process.exit(1);
+      }
+      if (result.value.length === 0) {
+        empty("No articles generated yet.");
+        nextSteps(['thoth generate_article --topic "<topic>"']);
+        closeDatabase();
+        return;
+      }
+      heading("Articles");
+      for (const article2 of result.value) {
+        item(article2.id, `${article2.title} (${article2.wordCount} words, ${article2.status})`);
+      }
+      closeDatabase();
+    });
+  });
+  program2.command("get_article").description("Show an article by ID").argument("<id>", "Article ID").action(async (id) => {
+    await withCliError(logger, "Article get", async () => {
+      const repo = createArticleRepository();
+      const result = await repo.get(id);
+      if (!result.ok) {
+        error(`Failed to get article: ${result.error}`);
+        process.exit(1);
+      }
+      if (!result.value) {
+        error(`Article not found: ${id}`);
+        process.exit(1);
+      }
+      heading(result.value.title);
+      meta("Words", result.value.wordCount);
+      meta("Status", result.value.status);
+      meta("Created", result.value.createdAt.toLocaleString());
+      blank();
+      divider();
+      article(result.value.content);
+      divider();
+      closeDatabase();
+    });
+  });
+}
+
+// src/cli/commands/export.command.ts
+import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join5, resolve as resolve2 } from "path";
+import { homedir as homedir5 } from "os";
+var VALID_ARTICLE_FORMATS = ["md", "html", "txt"];
+var VALID_SERIES_FORMATS = ["md", "html", "rss"];
+function defaultOutputDir(type) {
+  const config = loadConfig();
+  if (config.export?.outputDir) return join5(config.export.outputDir, type);
+  return join5(homedir5(), "Documents", "Thoth", type);
+}
+function registerExportCommand(program2) {
+  program2.command("export_article").description("Export an article (--format md|html|txt, --output <path>)").argument("<id>", "Article ID").option("-f, --format <format>", "Output format (md, html, txt)", "md").option("-o, --output <path>", "Output directory", defaultOutputDir("singles")).action(async (id, options) => {
+    await withCliError(logger, "Export article", async () => {
+      if (!VALID_ARTICLE_FORMATS.includes(options.format)) {
+        error(`Invalid format. Choose one of: ${VALID_ARTICLE_FORMATS.join(", ")}`);
+        process.exit(1);
+      }
+      const useCase = createExportArticleUseCase();
+      const result = await useCase.execute({
+        articleId: id,
+        format: options.format
+      });
+      if (!result.ok) {
+        error(`Export failed: ${result.error}`);
+        process.exit(1);
+      }
+      const outDir = resolve2(options.output);
+      if (!existsSync3(outDir)) {
+        mkdirSync3(outDir, { recursive: true });
+      }
+      const outPath = join5(outDir, result.value.filename);
+      writeFileSync2(outPath, result.value.content, "utf-8");
+      blank();
+      success("Article exported.");
+      summary({
+        Title: result.value.filename.replace(/\.[^.]+$/, ""),
+        Format: options.format,
+        Path: outPath
+      });
+      closeDatabase();
+    });
+  });
+  program2.command("export_series").description("Export a series (--format md|html|rss, --output <path>)").argument("<id>", "Series ID").option("-f, --format <format>", "Output format (md, html, rss)", "md").option("-o, --output <path>", "Output directory", defaultOutputDir("series")).action(async (id, options) => {
+    await withCliError(logger, "Export series", async () => {
+      if (!VALID_SERIES_FORMATS.includes(options.format)) {
+        error(`Invalid format. Choose one of: ${VALID_SERIES_FORMATS.join(", ")}`);
+        process.exit(1);
+      }
+      const useCase = createExportSeriesUseCase();
+      const result = await useCase.execute({
+        seriesId: id,
+        format: options.format
+      });
+      if (!result.ok) {
+        error(`Export failed: ${result.error}`);
+        process.exit(1);
+      }
+      const outDir = resolve2(options.output);
+      if (!existsSync3(outDir)) {
+        mkdirSync3(outDir, { recursive: true });
+      }
+      const outPath = join5(outDir, result.value.filename);
+      writeFileSync2(outPath, result.value.content, "utf-8");
+      blank();
+      success("Series exported.");
+      summary({
+        Title: result.value.filename.replace(/\.[^.]+$/, ""),
+        Format: options.format,
+        Path: outPath
+      });
+      closeDatabase();
+    });
+  });
+}
+
+// src/cli/commands/import.command.ts
+import cliProgress from "cli-progress";
+function registerImportCommand(program2) {
+  program2.command("import_voice").description("Import voice sources (journals, essays, blog posts)").argument("<path>", "File or directory path").action(async (sourcePath) => {
+    await runImport(sourcePath, "voice");
+  });
+  program2.command("import_knowledge").description("Import knowledge sources (technical notes, docs, repos)").argument("<path>", "File or directory path").action(async (sourcePath) => {
+    await runImport(sourcePath, "knowledge");
+  });
+  program2.command("import_publications").description("Import publication sources (articles, series)").argument("<path>", "File or directory path").action(async (sourcePath) => {
+    await runImport(sourcePath, "publication");
+  });
+}
+async function runImport(sourcePath, type) {
+  await withCliError(logger, "Import", async () => {
+    const useCase = createImportSourcesUseCase();
+    const startTime = process.hrtime();
+    heading(`Importing ${type} sources`);
+    meta("Path", sourcePath);
+    const importResult = await useCase.execute(sourcePath, type);
+    if (!importResult.ok) {
+      error(`Import failed: ${importResult.error}`);
+      closeDatabase();
+      return;
+    }
+    const count = importResult.value;
+    success(`Imported ${count} chunks.`);
+    const embedBar = new cliProgress.SingleBar({
+      format: `  ${color.cyan("Embedding")} [{bar}] {percentage}% | {value}/{total} chunks | {duration_formatted}`,
+      barCompleteChar: "\u2588",
+      barIncompleteChar: "\u2591",
+      hideCursor: true
+    });
+    let embedOk = true;
+    let embedFailed = 0;
+    let embedTotal = 0;
+    if (count > 0) {
+      step("Generating embeddings...");
+      try {
+        embedBar.start(count, 0);
+        const embedResult = await useCase.generateEmbeddingsForType(type, (current) => {
+          embedBar.update(current);
+        });
+        embedBar.stop();
+        if (!embedResult.ok) {
+          warn(`Embedding failed: ${embedResult.error}`);
+          embedOk = false;
+        } else {
+          embedFailed = embedResult.value.failed;
+          embedTotal = embedResult.value.total;
+          if (embedFailed > 0) {
+            warn(`${embedFailed} of ${embedTotal} embeddings failed.`);
+            if (embedFailed === embedTotal) {
+              warn("Check that your embedding provider is configured correctly.");
+            }
+          } else {
+            success("Embeddings complete.");
+          }
+        }
+      } catch (error2) {
+        embedBar.stop();
+        warn("Embedding generation failed. You can retry by running import again.");
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        warn(message);
+        embedOk = false;
+      }
+    }
+    closeDatabase();
+    const duration = timer(startTime);
+    blank();
+    success("Import complete.");
+    divider();
+    summary({
+      Type: type,
+      "Chunks imported": String(count),
+      Embeddings: count === 0 ? "none" : !embedOk ? "failed" : embedFailed === 0 ? "complete" : `${embedFailed}/${embedTotal} failed`,
+      Duration: duration
+    });
+    blank();
+    nextSteps(["thoth generate_profile  Create identity profiles from imported sources"]);
+  });
+}
+
+// src/cli/commands/init.command.ts
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize Thoth \u2014 create database and run migrations").action(async () => {
+    await withCliError(logger, "Init", async () => {
+      logger.info("Initializing Thoth");
+      const sourceRepo = createSourceRepository();
+      const [voiceCount, knowledgeCount, pubCount] = await Promise.all([
+        sourceRepo.getSourceCountByType("voice"),
+        sourceRepo.getSourceCountByType("knowledge"),
+        sourceRepo.getSourceCountByType("publication")
+      ]);
+      const counts = {
+        voice: voiceCount.ok ? voiceCount.value : 0,
+        knowledge: knowledgeCount.ok ? knowledgeCount.value : 0,
+        publication: pubCount.ok ? pubCount.value : 0
+      };
+      logger.info(
+        { dbPath: process.env.THOTH_DB_PATH ?? "~/.thoth/thoth.db", ...counts },
+        "Thoth initialized successfully"
+      );
+      success("Thoth initialized.");
+      meta("Database", "~/.thoth/thoth.db");
+      meta(
+        "Sources",
+        `${counts.voice} voice, ${counts.knowledge} knowledge, ${counts.publication} publication`
+      );
+      blank();
+      const isLocal = process.env.THOTH_LOCAL === "true";
+      if (!isLocal) {
+        section("Privacy notice");
+        warn("  Thoth sends source content to external AI providers (OpenAI, Groq, Gemini)");
+        warn("  for profile generation and embedding.");
+        info("Run with --local to use only local AI (Ollama) and keep data on device.");
+        blank();
+      }
+      nextSteps([
+        "thoth import_voice <path>         Import voice sources",
+        "thoth import_knowledge <path>     Import knowledge sources",
+        "thoth import_publications <path>  Import publication sources",
+        "thoth generate_profile            Generate identity profiles",
+        'thoth research "<topic>"          Research a topic using your knowledge',
+        "thoth generate_article --topic    Generate an article in your voice",
+        "thoth create_series <name>        Group articles into series"
+      ]);
+      closeDatabase();
+    });
+  });
+}
+
+// src/cli/commands/profile.command.ts
+function preview(value) {
+  if (typeof value !== "string") return "";
+  return `${value.slice(0, 60)}...`;
+}
+function registerProfileCommand(program2) {
+  program2.command("generate_profile").description("Generate identity profiles from imported sources").action(async () => {
+    await withCliError(logger, "Profile generation", async () => {
+      const useCase = createGenerateProfilesUseCase();
+      const sourceRepo = createSourceRepository();
+      const [voiceCount, knowledgeCount, pubCount] = await Promise.all([
+        sourceRepo.getSourceCountByType("voice"),
+        sourceRepo.getSourceCountByType("knowledge"),
+        sourceRepo.getSourceCountByType("publication")
+      ]);
+      const counts = {
+        voice: voiceCount.ok ? voiceCount.value : 0,
+        knowledge: knowledgeCount.ok ? knowledgeCount.value : 0,
+        publication: pubCount.ok ? pubCount.value : 0
+      };
+      if (counts.voice === 0 && counts.knowledge === 0 && counts.publication === 0) {
+        error("No sources imported.");
+        nextSteps(["thoth import_voice <path>  Import writing samples"]);
+        process.exit(1);
+      }
+      heading("Generating identity profiles");
+      meta("Voice chunks", counts.voice);
+      meta("Knowledge chunks", counts.knowledge);
+      meta("Publication chunks", counts.publication);
+      blank();
+      let generatedCount = 0;
+      const failures = [];
+      const startTime = process.hrtime();
+      if (counts.voice > 0) {
+        const spin = spinner("Generating voice profile...");
+        spin.start();
+        const result = await useCase.generateVoiceProfile();
+        spin.stop();
+        if (!result.ok) {
+          error(`Voice profile failed: ${result.error}`);
+          failures.push(`voice: ${result.error}`);
+        } else {
+          generatedCount += 1;
+          success("Voice profile generated");
+          meta("Summary", result.value.summary ?? "No summary");
+        }
+      }
+      if (counts.knowledge > 0) {
+        const spin = spinner("Generating knowledge profile...");
+        spin.start();
+        const result = await useCase.generateKnowledgeProfile();
+        spin.stop();
+        if (!result.ok) {
+          error(`Knowledge profile failed: ${result.error}`);
+          failures.push(`knowledge: ${result.error}`);
+        } else {
+          generatedCount += 1;
+          success("Knowledge profile generated");
+          meta("Domains", result.value.domains.join(", "));
+        }
+      }
+      if (counts.publication > 0) {
+        const spin = spinner("Generating publication profile...");
+        spin.start();
+        const result = await useCase.generatePublicationProfile();
+        spin.stop();
+        if (!result.ok) {
+          error(`Publication profile failed: ${result.error}`);
+          failures.push(`publication: ${result.error}`);
+        } else {
+          generatedCount += 1;
+          success("Publication profile generated");
+          meta("Themes", result.value.themes.join(", "));
+        }
+      }
+      const duration = timer(startTime);
+      blank();
+      if (failures.length > 0) {
+        error(
+          generatedCount > 0 ? `Profile generation completed with ${failures.length} failure(s).` : "Profile generation failed."
+        );
+        closeDatabase();
+        process.exit(1);
+      }
+      divider();
+      summary({
+        Generated: `${generatedCount} of 3`,
+        Duration: duration
+      });
+      blank();
+      nextSteps([
+        "thoth profile_status             Review profile readiness",
+        'thoth research "<topic>"         Research from imported knowledge',
+        "thoth generate_article --topic   Draft in your voice"
+      ]);
+      closeDatabase();
+    });
+  });
+  program2.command("profile_status").description("Show profile generation status").action(async () => {
+    await withCliError(logger, "Status check", async () => {
+      const profileRepo = createProfileRepository();
+      const sourceRepo = createSourceRepository();
+      const [voiceCount, knowledgeCount, pubCount, statusResult] = await Promise.all([
+        sourceRepo.getSourceCountByType("voice"),
+        sourceRepo.getSourceCountByType("knowledge"),
+        sourceRepo.getSourceCountByType("publication"),
+        profileRepo.getProfileStatus()
+      ]);
+      if (!statusResult.ok) {
+        error(`Status check failed: ${statusResult.error}`);
+        process.exit(1);
+      }
+      const status = statusResult.value;
+      heading("Thoth status");
+      section("Sources");
+      meta("Voice", `${voiceCount.ok ? voiceCount.value : 0} chunks`);
+      meta("Knowledge", `${knowledgeCount.ok ? knowledgeCount.value : 0} chunks`);
+      meta("Publications", `${pubCount.ok ? pubCount.value : 0} chunks`);
+      blank();
+      section("Profiles");
+      meta(
+        "Voice",
+        status.voice.exists ? `${color.green("[ready]")} ${preview(status.voice.summary)}` : `${color.yellow("[missing]")} Not generated`
+      );
+      meta(
+        "Knowledge",
+        status.knowledge.exists ? `${color.green("[ready]")} ${preview(status.knowledge.domains)}` : `${color.yellow("[missing]")} Not generated`
+      );
+      meta(
+        "Publication",
+        status.publication.exists ? `${color.green("[ready]")} ${preview(status.publication.themes)}` : `${color.yellow("[missing]")} Not generated`
+      );
+      closeDatabase();
+    });
+  });
+}
+
+// src/cli/commands/research.command.ts
+function registerResearchCommand(program2) {
+  program2.command("research").description("Research a topic using imported knowledge sources").argument("<topic>", "Topic to research").action(async (topic) => {
+    await withCliError(logger, "Research", async () => {
+      if (topic.length > 500) {
+        error("Topic must be under 500 characters.");
+        process.exit(1);
+      }
+      const useCase = createResearchUseCase();
+      heading("Researching");
+      meta("Topic", topic);
+      blank();
+      const spin = spinner("Researching...");
+      const startTime = process.hrtime();
+      spin.start();
+      const result = await useCase.execute(topic);
+      spin.stop();
+      const duration = timer(startTime);
+      if (!result.ok) {
+        error(`Research failed: ${result.error}`);
+        process.exit(1);
+      }
+      divider();
+      output(result.value.content);
+      divider();
+      blank();
+      success("Research complete.");
+      meta("Duration", duration);
+      meta("Sources cited", result.value.citations.length);
+      meta("Research ID", result.value.id);
+      blank();
+      section("Citations");
+      for (const citation of result.value.citations) {
+        item(`[${citation.sourceId.slice(0, 8)}]`, citation.sourcePath);
+        meta("Relevance", `${(citation.relevanceScore * 100).toFixed(0)}%`);
+        empty(`  "${citation.excerpt.slice(0, 120)}..."`);
+        blank();
+      }
+      closeDatabase();
+    });
+  });
+}
+
+// src/cli/commands/series.command.ts
+function registerSeriesCommand(program2) {
+  program2.command("create_series").description("Create a new series (--description <text>)").argument("<name>", "Series name").option("-d, --description <text>", "Series description").action(async (name, options) => {
+    await withCliError(logger, "Series create", async () => {
+      if (name.length > 200) {
+        error("Series name must be under 200 characters.");
+        process.exit(1);
+      }
+      if (options.description && options.description.length > 1e3) {
+        error("Description must be under 1000 characters.");
+        process.exit(1);
+      }
+      const useCase = createSeriesUseCase();
+      const result = await useCase.create(name, options.description);
+      if (!result.ok) {
+        error(`Failed to create series: ${result.error}`);
+        process.exit(1);
+      }
+      success(`Series created: ${result.value.name}`);
+      meta("ID", result.value.id);
+      closeDatabase();
+    });
+  });
+  program2.command("list_series").description("List all series").action(async () => {
+    await withCliError(logger, "Series list", async () => {
+      const useCase = createSeriesUseCase();
+      const result = await useCase.list();
+      if (!result.ok) {
+        error(`Failed to list series: ${result.error}`);
+        process.exit(1);
+      }
+      if (result.value.length === 0) {
+        empty("No series created yet.");
+        nextSteps(["thoth create_series <name>"]);
+        closeDatabase();
+        return;
+      }
+      heading("Series");
+      for (const series of result.value) {
+        item(series.id.slice(0, 8), `${series.name} (${series.articleIds.length} articles)`);
+        if (series.description) {
+          empty(`  ${series.description}`);
+        }
+      }
+      closeDatabase();
+    });
+  });
+  program2.command("add_to_series").description("Add an article to a series").argument("<series-id>", "Series ID").argument("<article-id>", "Article ID").action(async (seriesId, articleId) => {
+    await withCliError(logger, "Series add", async () => {
+      const useCase = createSeriesUseCase();
+      const result = await useCase.addArticle(seriesId, articleId);
+      if (!result.ok) {
+        error(`Failed to add article: ${result.error}`);
+        process.exit(1);
+      }
+      success(`Article ${articleId.slice(0, 8)} added to series ${seriesId.slice(0, 8)}`);
+      closeDatabase();
+    });
+  });
+  program2.command("get_series").description("Show series details").argument("<id>", "Series ID").action(async (id) => {
+    await withCliError(logger, "Series get", async () => {
+      const useCase = createSeriesUseCase();
+      const result = await useCase.get(id);
+      if (!result.ok) {
+        error(`Failed to get series: ${result.error}`);
+        process.exit(1);
+      }
+      if (!result.value) {
+        error(`Series not found: ${id}`);
+        process.exit(1);
+      }
+      heading(result.value.name);
+      if (result.value.description) meta("Description", result.value.description);
+      meta("Created", result.value.createdAt.toLocaleString());
+      meta("Articles", result.value.articleIds.length);
+      blank();
+      for (const articleId of result.value.articleIds) {
+        item(articleId.slice(0, 8), articleId);
+      }
+      closeDatabase();
+    });
+  });
+}
+
+// src/cli/commands/publish.command.ts
+async function promptCookie(label) {
+  const { stdin, stdout } = process;
+  return new Promise((resolve3) => {
+    stdout.write(`  ${label}: `);
+    stdin.once("data", (data) => {
+      resolve3(data.toString().trim());
+    });
+  });
+}
+function registerPublishCommand(program2) {
+  program2.command("connect_medium").description("Save Medium session cookies for publishing (no password handling)").action(async () => {
+    await withCliError(logger, "Connect Medium", async () => {
+      heading("Connect to Medium");
+      empty("");
+      info("Open medium.com in your browser and log in.");
+      info("Then open DevTools:");
+      info("  Chrome:  View \u2192 Developer \u2192 Developer Tools \u2192 Application \u2192 Cookies");
+      info("  Firefox: Tools \u2192 Web Developer \u2192 Storage Inspector \u2192 Cookies");
+      info("  Safari:  Develop \u2192 Show Web Inspector \u2192 Storage \u2192 Cookies");
+      empty("");
+      info("Copy the values for these two cookies:");
+      empty("");
+      const sid = await promptCookie("sid");
+      const uid = await promptCookie("uid");
+      if (!sid || !uid) {
+        error("Both sid and uid cookies are required.");
+        process.exit(1);
+      }
+      const adapter = createMediumAdapter();
+      const result = await adapter.connect({ sid, uid });
+      if (!result.ok) {
+        error(`Failed to save credentials: ${result.error}`);
+        process.exit(1);
+      }
+      blank();
+      success("Credentials saved to ~/.thoth/medium-credentials.json");
+      info("You can now run `thoth publish <article-id>` to publish to Medium.");
+      closeDatabase();
+    });
+  });
+  program2.command("publish").description("Publish an article to Medium as a draft").argument("<id>", "Article ID to publish").action(async (id) => {
+    await withCliError(logger, "Publish to Medium", async () => {
+      const adapter = createMediumAdapter();
+      const authenticated = await adapter.isAuthenticated();
+      if (!authenticated) {
+        error("Not authenticated. Run `thoth connect_medium` first.");
+        process.exit(1);
+      }
+      const spin = spinner("Publishing to Medium...");
+      spin.start();
+      const useCase = createPublishArticleUseCase();
+      const result = await useCase.execute(id);
+      spin.stop();
+      if (!result.ok) {
+        error(`Publish failed: ${result.error}`);
+        process.exit(1);
+      }
+      blank();
+      success("Article published to Medium.");
+      summary({
+        Article: result.value.title,
+        URL: result.value.mediumUrl ?? "(not set)",
+        Status: result.value.status
+      });
+      closeDatabase();
+    });
+  });
+}
+
+// src/cli/index.ts
+var activeConfig = null;
+function createCli() {
+  const program2 = new Command();
+  program2.name("thoth").description("Identity Preserving Publishing Engine").version("1.0.0").option("--local", "Use only local AI (Ollama). No data sent to external providers").option("--provider <name>", "AI provider to use (openai, groq, gemini, anthropic, ollama)");
+  program2.hook("preAction", (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    activeConfig = resolveConfig(
+      typeof opts.local === "boolean" ? opts.local : typeof opts.local === "string" ? opts.local === "true" : void 0,
+      typeof opts.provider === "string" ? opts.provider : void 0
+    );
+    applyConfig(activeConfig);
+    if (activeConfig.dbPath) {
+      setDbPath(activeConfig.dbPath);
+    }
+  });
+  registerInitCommand(program2);
+  registerImportCommand(program2);
+  registerProfileCommand(program2);
+  registerResearchCommand(program2);
+  registerArticleCommand(program2);
+  registerSeriesCommand(program2);
+  registerExportCommand(program2);
+  registerPublishCommand(program2);
+  return program2;
+}
+
+// src/index.ts
+var program = createCli();
+program.parse();