@hasna/search 0.0.8 → 0.0.9

package/dist/cli/index.js

@@ -993,7 +993,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {}
+          }
         };
       }
       return this;
@@ -2097,7 +2097,7 @@ function runMigrations(db) {
     db.exec("BEGIN");
     try {
       migration.up(db);
-      db.prepare("INSERT INTO _migrations (version, description) VALUES (?, ?)").run(migration.version, migration.description);
+      db.prepare("INSERT OR IGNORE INTO _migrations (version, description) VALUES (?, ?)").run(migration.version, migration.description);
       db.exec("COMMIT");
     } catch (err) {
       db.exec("ROLLBACK");
@@ -2234,6 +2234,34 @@ var init_migrations = __esm(() => {
           ('prof-all',       'all',       'All enabled providers',                            '["google","serpapi","exa","perplexity","brave","bing","twitter","reddit","youtube","hackernews","github","arxiv"]', '{}', datetime('now'));
       `);
       }
+    },
+    {
+      version: 4,
+      description: "Local search providers (files, content) and local profile",
+      up: (db) => {
+        db.exec(`
+        INSERT OR IGNORE INTO providers (name, enabled, api_key_env, rate_limit, metadata) VALUES
+          ('files',   1, '', 0, '{}'),
+          ('content', 1, '', 0, '{}');
+
+        INSERT OR IGNORE INTO search_profiles (id, name, description, providers, options, created_at) VALUES
+          ('prof-local', 'local', 'Local filesystem: file paths + content', '["files","content"]', '{}', datetime('now'));
+      `);
+        const row = db.query("SELECT id, providers FROM search_profiles WHERE name = 'all'").get();
+        if (row) {
+          let providers;
+          try {
+            providers = JSON.parse(row.providers);
+          } catch {
+            providers = [];
+          }
+          for (const name of ["files", "content"]) {
+            if (!providers.includes(name))
+              providers.push(name);
+          }
+          db.prepare("UPDATE search_profiles SET providers = ? WHERE id = ?").run(JSON.stringify(providers), row.id);
+        }
+      }
     }
   ];
 });
@@ -2247,18 +2275,7 @@ __export(exports_database, {
   closeDb: () => closeDb
 });
 import { Database } from "bun:sqlite";
-import { cpSync, existsSync as existsSync2, mkdirSync } from "fs";
-function migrateDotfile() {
-  const home = Bun.env.HOME ?? "/tmp";
-  const oldDir = `${home}/.search`;
-  const newDir = `${home}/.hasna/search`;
-  if (existsSync2(newDir) || !existsSync2(oldDir))
-    return;
-  try {
-    mkdirSync(`${home}/.hasna`, { recursive: true });
-    cpSync(oldDir, newDir, { recursive: true });
-  } catch {}
-}
+import { mkdirSync } from "fs";
 function ensureFeedbackTable(db) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS feedback (
@@ -2277,18 +2294,19 @@ function getDbPath() {
   if (envPath)
     return envPath;
   const home = Bun.env.HOME ?? "/tmp";
-  migrateDotfile();
-  const newDir = `${home}/.hasna/search`;
-  mkdirSync(newDir, { recursive: true });
-  return `${newDir}/data.db`;
+  const dir = `${home}/.hasna/search`;
+  mkdirSync(dir, { recursive: true });
+  return `${dir}/data.db`;
 }
 function getDb() {
   if (instance)
     return instance;
   const path = getDbPath();
   const db = new Database(path);
-  db.exec("PRAGMA synchronous = NORMAL");
   db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA synchronous = NORMAL");
   runMigrations(db);
   ensureFeedbackTable(db);
   instance = db;
@@ -7393,8 +7411,8 @@ var init_pg_migrate = __esm(() => {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "@hasna/search",
-    version: "0.0.8",
-    description: "Unified search aggregator \u2014 12 providers (Google, SerpAPI, Exa, Perplexity, Twitter, Reddit, YouTube, Brave, Bing, Hacker News, GitHub, arXiv) + YouTube transcription. CLI + MCP + REST API + Dashboard.",
+    version: "0.0.9",
+    description: "Unified search \u2014 local file index (find files by name/path/content/regex in ms, trigram FTS) + 12 web providers (Google, SerpAPI, Exa, Perplexity, Twitter, Reddit, YouTube, Brave, Bing, Hacker News, GitHub, arXiv) + YouTube transcription. CLI + MCP + REST API + Dashboard.",
     type: "module",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -7407,6 +7425,10 @@ var require_package = __commonJS((exports, module) => {
       ".": {
         types: "./dist/index.d.ts",
         import: "./dist/index.js"
+      },
+      "./storage": {
+        types: "./dist/storage.d.ts",
+        import: "./dist/storage.js"
       }
     },
     files: [
@@ -7415,8 +7437,9 @@ var require_package = __commonJS((exports, module) => {
       "README.md"
     ],
     scripts: {
-      build: "cd dashboard && bun run build && cd .. && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk && bun build src/mcp/index.ts --outdir dist/mcp --target bun && bun build src/server/index.ts --outdir dist/server --target bun && bun build src/index.ts --outdir dist --target bun && tsc --emitDeclarationOnly --outDir dist",
-      "build:no-dashboard": "bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk && bun build src/mcp/index.ts --outdir dist/mcp --target bun && bun build src/server/index.ts --outdir dist/server --target bun && bun build src/index.ts --outdir dist --target bun && tsc --emitDeclarationOnly --outDir dist",
+      clean: "rm -rf dist",
+      build: "bun run clean && cd dashboard && bun run build && cd .. && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk && bun build src/mcp/index.ts --outdir dist/mcp --target bun && bun build src/server/index.ts --outdir dist/server --target bun && bun build src/index.ts src/storage.ts --outdir dist --target bun && tsc --emitDeclarationOnly --outDir dist",
+      "build:no-dashboard": "bun run clean && bun build src/cli/index.tsx --outdir dist/cli --target bun --external ink --external react --external chalk && bun build src/mcp/index.ts --outdir dist/mcp --target bun && bun build src/server/index.ts --outdir dist/server --target bun && bun build src/index.ts src/storage.ts --outdir dist --target bun && tsc --emitDeclarationOnly --outDir dist",
       typecheck: "tsc --noEmit",
       test: "bun test",
       "dev:cli": "bun run src/cli/index.tsx",
@@ -7427,6 +7450,13 @@ var require_package = __commonJS((exports, module) => {
     },
     keywords: [
       "search",
+      "local-search",
+      "file-search",
+      "code-search",
+      "grep",
+      "trigram",
+      "fts5",
+      "indexing",
       "meta-search",
       "aggregator",
       "google",
@@ -7498,70 +7528,95 @@ var {
 } = import__.default;
 
 // src/cli/index.tsx
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
-// src/cli/cloud.ts
+// src/cli/storage.ts
 import chalk from "chalk";
 
-// src/db/cloud-config.ts
+// src/db/storage-config.ts
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-var CONFIG_PATH = join(homedir(), ".hasna", "search", "cloud", "config.json");
-function isMode(value) {
-  return value === "local" || value === "hybrid" || value === "cloud";
-}
-function envConnectionString() {
-  return Bun.env.HASNA_SEARCH_CLOUD_DATABASE_URL ?? Bun.env.OPEN_SEARCH_CLOUD_DATABASE_URL ?? Bun.env.SEARCH_CLOUD_DATABASE_URL;
-}
-function getCloudConfig() {
+var STORAGE_CONFIG_PATH = join(homedir(), ".hasna", "search", "storage", "config.json");
+var SEARCH_STORAGE_ENV = "HASNA_SEARCH_DATABASE_URL";
+var SEARCH_STORAGE_FALLBACK_ENV = "SEARCH_DATABASE_URL";
+var SEARCH_STORAGE_MODE_ENV = "HASNA_SEARCH_STORAGE_MODE";
+var SEARCH_STORAGE_MODE_FALLBACK_ENV = "SEARCH_STORAGE_MODE";
+var STORAGE_DATABASE_ENV = [SEARCH_STORAGE_ENV, SEARCH_STORAGE_FALLBACK_ENV];
+function readEnv(name) {
+  const value = process.env[name]?.trim();
+  return value || undefined;
+}
+function normalizeMode(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "local" || normalized === "hybrid" || normalized === "remote")
+    return normalized;
+  return;
+}
+function getStorageDatabaseEnvName() {
+  for (const name of STORAGE_DATABASE_ENV) {
+    if (readEnv(name))
+      return name;
+  }
+  return null;
+}
+function getStorageDatabaseEnv() {
+  const name = getStorageDatabaseEnvName();
+  return name ? { name } : null;
+}
+function getStorageDatabaseUrl() {
+  const env = getStorageDatabaseEnv();
+  return env ? readEnv(env.name) : undefined;
+}
+function getStorageConfig() {
   const config = {
     mode: "local",
     rds: {
       host: "",
       port: 5432,
       username: "",
-      password_env: "SEARCH_CLOUD_DATABASE_PASSWORD",
+      password_env: "SEARCH_DATABASE_PASSWORD",
       ssl: true
     }
   };
-  if (existsSync(CONFIG_PATH)) {
+  if (existsSync(STORAGE_CONFIG_PATH)) {
     try {
-      const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
-      config.mode = raw.mode ?? config.mode;
+      const raw = JSON.parse(readFileSync(STORAGE_CONFIG_PATH, "utf-8"));
+      config.mode = normalizeMode(raw.mode) ?? config.mode;
       config.rds = { ...config.rds, ...raw.rds ?? {} };
     } catch {}
   }
-  const modeOverride = Bun.env.HASNA_SEARCH_CLOUD_MODE ?? Bun.env.OPEN_SEARCH_CLOUD_MODE ?? Bun.env.SEARCH_CLOUD_MODE;
-  if (isMode(modeOverride)) {
-    config.mode = modeOverride;
-  } else if (envConnectionString() && config.mode === "local") {
+  const modeOverride = readEnv(SEARCH_STORAGE_MODE_ENV) ?? readEnv(SEARCH_STORAGE_MODE_FALLBACK_ENV);
+  const normalizedMode = normalizeMode(modeOverride);
+  if (normalizedMode) {
+    config.mode = normalizedMode;
+  } else if (getStorageDatabaseUrl() && config.mode === "local") {
     config.mode = "hybrid";
   }
   return config;
 }
-function getConnectionString(dbName = "search") {
-  const direct = envConnectionString();
+function getStorageConnectionString(dbName = "search") {
+  const direct = getStorageDatabaseUrl();
   if (direct)
     return direct;
-  const config = getCloudConfig();
+  const config = getStorageConfig();
   const { host, port, username, password_env, ssl } = config.rds;
   if (!host || !username) {
-    throw new Error("Cloud database is not configured. Set HASNA_SEARCH_CLOUD_DATABASE_URL or configure ~/.hasna/search/cloud/config.json.");
+    throw new Error("Storage database is not configured. Set HASNA_SEARCH_DATABASE_URL or configure ~/.hasna/search/storage/config.json.");
   }
-  const password = Bun.env[password_env];
+  const password = process.env[password_env];
   if (!password) {
-    throw new Error(`Cloud database password is not set. Export ${password_env}.`);
+    throw new Error(`Storage database password is not set. Export ${password_env}.`);
   }
   const sslParam = ssl ? "?sslmode=require" : "";
   return `postgres://${username}:${encodeURIComponent(password)}@${host}:${port}/${dbName}${sslParam}`;
 }
 
-// src/db/cloud-sync.ts
+// src/db/storage-sync.ts
 init_database();
 init_remote_storage();
 init_pg_migrations();
-var CLOUD_TABLES = [
+var STORAGE_TABLES = [
   "searches",
   "search_results",
   "saved_searches",
@@ -7648,21 +7703,26 @@ function upsertSqlite(db, table, rows) {
   }
   return written;
 }
-async function getCloudPg() {
-  return new PgAdapterAsync(getConnectionString("search"));
+async function getStoragePg() {
+  return new PgAdapterAsync(getStorageConnectionString("search"));
 }
-async function runCloudMigrations(remote) {
+async function runStorageMigrations(remote) {
   for (const migration of PG_MIGRATIONS) {
     await remote.exec(migration);
   }
 }
-function getCloudStatus(db = getDb()) {
-  const config = getCloudConfig();
+function getStorageStatus(db = getDb()) {
+  const config = getStorageConfig();
+  const activeEnv = getStorageDatabaseEnv();
   return {
+    configured: Boolean(activeEnv) || Boolean(config.rds.host && config.rds.username),
     mode: config.mode,
-    enabled: config.mode === "hybrid" || config.mode === "cloud",
+    enabled: config.mode === "hybrid" || config.mode === "remote",
+    env: STORAGE_DATABASE_ENV,
+    activeEnv: activeEnv?.name ?? null,
+    service: "search",
     db_path: getDbPath(),
-    tables: CLOUD_TABLES.map((table) => {
+    tables: STORAGE_TABLES.map((table) => {
       try {
         const row = db.query(`SELECT COUNT(*) as count FROM ${quoteId(table)}`).get();
         return { table, rows: row.count };
@@ -7672,12 +7732,12 @@ function getCloudStatus(db = getDb()) {
     })
   };
 }
-async function pushCloudChanges(tables = [...CLOUD_TABLES]) {
+async function pushStorageChanges(tables = [...STORAGE_TABLES]) {
   const db = getDb();
-  const remote = await getCloudPg();
+  const remote = await getStoragePg();
   const results = [];
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     for (const table of tables) {
       const result = { table, direction: "push", rowsRead: 0, rowsWritten: 0, errors: [] };
       try {
@@ -7694,12 +7754,12 @@ async function pushCloudChanges(tables = [...CLOUD_TABLES]) {
   }
   return results;
 }
-async function pullCloudChanges(tables = [...CLOUD_TABLES]) {
+async function pullStorageChanges(tables = [...STORAGE_TABLES]) {
   const db = getDb();
-  const remote = await getCloudPg();
+  const remote = await getStoragePg();
   const results = [];
   try {
-    await runCloudMigrations(remote);
+    await runStorageMigrations(remote);
     for (const table of tables) {
       const result = { table, direction: "pull", rowsRead: 0, rowsWritten: 0, errors: [] };
       try {
@@ -7716,20 +7776,24 @@ async function pullCloudChanges(tables = [...CLOUD_TABLES]) {
   }
   return results;
 }
-async function syncCloudChanges(tables = [...CLOUD_TABLES]) {
+async function syncStorageChanges(tables = [...STORAGE_TABLES]) {
   return {
-    push: await pushCloudChanges(tables),
-    pull: await pullCloudChanges(tables)
+    push: await pushStorageChanges(tables),
+    pull: await pullStorageChanges(tables)
   };
 }
-function parseCloudTables(raw) {
+function parseStorageTables(raw) {
   if (!raw)
-    return [...CLOUD_TABLES];
+    return [...STORAGE_TABLES];
   const requested = raw.split(",").map((table) => table.trim()).filter(Boolean);
-  return requested.length > 0 ? requested : [...CLOUD_TABLES];
+  const allowed = new Set(STORAGE_TABLES);
+  const invalid = requested.filter((table) => !allowed.has(table));
+  if (invalid.length > 0)
+    throw new Error(`Unknown search storage table(s): ${invalid.join(", ")}`);
+  return requested.length > 0 ? requested : [...STORAGE_TABLES];
 }
 
-// src/cli/cloud.ts
+// src/cli/storage.ts
 function printJson(value) {
   console.log(JSON.stringify(value, null, 2));
 }
@@ -7742,10 +7806,10 @@ function printResults(results) {
     }
   }
 }
-function registerCloudCommands(program2) {
-  const cloud = program2.command("cloud").description("Manage search local/remote cloud sync");
-  cloud.command("status").description("Show local database and cloud sync status").option("--json", "Output as JSON").action((opts) => {
-    const status = getCloudStatus();
+function registerStorageCommands(program2) {
+  const storage = program2.command("storage").description("Manage search local/remote storage sync");
+  storage.command("status").description("Show local database and storage sync status").option("--json", "Output as JSON").action((opts) => {
+    const status = getStorageStatus();
     if (opts.json) {
       printJson(status);
       return;
@@ -7757,9 +7821,9 @@ function registerCloudCommands(program2) {
       console.log(`  ${table.table}: ${table.rows}`);
     }
   });
-  cloud.command("push").description("Push local search data to PostgreSQL").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("push").description("Push local search data to PostgreSQL").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const results = await pushCloudChanges(parseCloudTables(opts.tables));
+      const results = await pushStorageChanges(parseStorageTables(opts.tables));
       if (opts.json)
         printJson(results);
       else
@@ -7772,9 +7836,9 @@ function registerCloudCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cloud.command("pull").description("Pull PostgreSQL search data into the local database").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("pull").description("Pull PostgreSQL search data into the local database").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const results = await pullCloudChanges(parseCloudTables(opts.tables));
+      const results = await pullStorageChanges(parseStorageTables(opts.tables));
       if (opts.json)
         printJson(results);
       else
@@ -7787,9 +7851,9 @@ function registerCloudCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cloud.command("sync").description("Push local changes, then pull remote changes").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("sync").description("Push local changes, then pull remote changes").option("--tables <tables>", "Comma-separated table names").option("--json", "Output as JSON").action(async (opts) => {
     try {
-      const result = await syncCloudChanges(parseCloudTables(opts.tables));
+      const result = await syncStorageChanges(parseStorageTables(opts.tables));
       if (opts.json) {
         printJson(result);
         return;
@@ -7806,10 +7870,10 @@ function registerCloudCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cloud.command("migrate").description("Apply PostgreSQL migrations").option("--connection-string <url>", "PostgreSQL connection string").option("--json", "Output as JSON").action(async (opts) => {
+  storage.command("migrate").description("Apply PostgreSQL migrations").option("--connection-string <url>", "PostgreSQL connection string").option("--json", "Output as JSON").action(async (opts) => {
     try {
       const { applyPgMigrations: applyPgMigrations2 } = await Promise.resolve().then(() => (init_pg_migrate(), exports_pg_migrate));
-      const result = await applyPgMigrations2(opts.connectionString || getConnectionString("search"));
+      const result = await applyPgMigrations2(opts.connectionString || getStorageConnectionString("search"));
       if (opts.json) {
         printJson(result);
         return;
@@ -7833,6 +7897,144 @@ function registerCloudCommands(program2) {
   });
 }
 
+// src/cli/local.ts
+import chalk2 from "chalk";
+
+// src/lib/local/indexer.ts
+import { readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, resolve } from "path";
+
+// src/db/index-db.ts
+import { Database as Database2 } from "bun:sqlite";
+import { mkdirSync as mkdirSync2 } from "fs";
+
+// src/db/index-migrations.ts
+var migrations2 = [
+  {
+    version: 1,
+    description: "Local file index core",
+    up: (db) => {
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS index_roots (
+          id TEXT PRIMARY KEY,
+          path TEXT NOT NULL UNIQUE,
+          name TEXT NOT NULL,
+          exclude TEXT NOT NULL DEFAULT '[]',
+          content_indexing INTEGER NOT NULL DEFAULT 1,
+          max_file_size INTEGER NOT NULL DEFAULT 524288,
+          status TEXT NOT NULL DEFAULT 'pending',
+          error TEXT,
+          file_count INTEGER NOT NULL DEFAULT 0,
+          last_indexed_at TEXT,
+          last_duration_ms INTEGER,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        );
+
+        CREATE TABLE IF NOT EXISTS files (
+          id INTEGER PRIMARY KEY,
+          root_id TEXT NOT NULL REFERENCES index_roots(id) ON DELETE CASCADE,
+          rel_path TEXT NOT NULL,
+          name TEXT NOT NULL,
+          ext TEXT NOT NULL DEFAULT '',
+          dir TEXT NOT NULL DEFAULT '',
+          size INTEGER NOT NULL,
+          mtime_ms INTEGER NOT NULL,
+          is_binary INTEGER NOT NULL DEFAULT 0,
+          content_indexed INTEGER NOT NULL DEFAULT 0,
+          indexed_at TEXT NOT NULL,
+          UNIQUE(root_id, rel_path)
+        );
+        CREATE INDEX IF NOT EXISTS idx_files_root ON files(root_id);
+        CREATE INDEX IF NOT EXISTS idx_files_name ON files(name);
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS files_fts USING fts5(
+          name, rel_path,
+          content='files',
+          content_rowid='id',
+          tokenize='trigram'
+        );
+
+        CREATE TRIGGER IF NOT EXISTS files_ai AFTER INSERT ON files BEGIN
+          INSERT INTO files_fts(rowid, name, rel_path)
+          VALUES (NEW.id, NEW.name, NEW.rel_path);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS files_ad AFTER DELETE ON files BEGIN
+          INSERT INTO files_fts(files_fts, rowid, name, rel_path)
+          VALUES ('delete', OLD.id, OLD.name, OLD.rel_path);
+        END;
+
+        CREATE TRIGGER IF NOT EXISTS files_au AFTER UPDATE OF name, rel_path ON files BEGIN
+          INSERT INTO files_fts(files_fts, rowid, name, rel_path)
+          VALUES ('delete', OLD.id, OLD.name, OLD.rel_path);
+          INSERT INTO files_fts(rowid, name, rel_path)
+          VALUES (NEW.id, NEW.name, NEW.rel_path);
+        END;
+
+        CREATE VIRTUAL TABLE IF NOT EXISTS file_content_fts USING fts5(
+          body,
+          content='',
+          contentless_delete=1,
+          tokenize='trigram'
+        );
+      `);
+    }
+  }
+];
+function runIndexMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      version INTEGER PRIMARY KEY,
+      description TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+  const applied = new Set(db.query("SELECT version FROM _migrations").all().map((row) => row.version));
+  for (const migration of migrations2) {
+    if (applied.has(migration.version))
+      continue;
+    db.exec("BEGIN");
+    try {
+      migration.up(db);
+      db.prepare("INSERT OR IGNORE INTO _migrations (version, description) VALUES (?, ?)").run(migration.version, migration.description);
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+  }
+}
+
+// src/db/index-db.ts
+var instance2 = null;
+function getIndexDbPath() {
+  const envPath = Bun.env.HASNA_SEARCH_INDEX_DB_PATH ?? Bun.env.SEARCH_INDEX_DB_PATH;
+  if (envPath)
+    return envPath;
+  const home = Bun.env.HOME ?? "/tmp";
+  const dir = `${home}/.hasna/search`;
+  mkdirSync2(dir, { recursive: true });
+  return `${dir}/index.db`;
+}
+function configure(db) {
+  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec("PRAGMA synchronous = NORMAL");
+  runIndexMigrations(db);
+  return db;
+}
+function getIndexDb() {
+  if (instance2)
+    return instance2;
+  instance2 = configure(new Database2(getIndexDbPath()));
+  return instance2;
+}
+
+// src/lib/config.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -11819,9 +12021,15 @@ var PROVIDER_NAMES = [
   "youtube",
   "hackernews",
   "github",
-  "arxiv"
+  "arxiv",
+  "files",
+  "content"
 ];
 var SearchProviderNameSchema = exports_external.enum(PROVIDER_NAMES);
+var LOCAL_PROVIDER_NAMES = new Set([
+  "files",
+  "content"
+]);
 var EXPORT_FORMATS = ["json", "csv", "md"];
 var ExportFormatSchema = exports_external.enum(EXPORT_FORMATS);
 var SearchOptionsSchema = exports_external.object({
@@ -11844,7 +12052,10 @@ var DEFAULT_CONFIG = {
     fallbackCli: "microservice-transcriber"
   },
   dedup: true,
-  maxConcurrent: 5
+  maxConcurrent: 5,
+  indexStaleMinutes: 5,
+  indexAutoRefresh: true,
+  recordLocalResults: false
 };
 var counter = 0;
 function generateId() {
@@ -11854,6 +12065,1320 @@ function generateId() {
   return `${timestamp}-${random}-${counter.toString(36)}`;
 }
 
+// src/lib/config.ts
+function getConfigDir() {
+  const home = Bun.env.HOME ?? "/tmp";
+  const dir = `${home}/.hasna/search`;
+  mkdirSync3(dir, { recursive: true });
+  return dir;
+}
+function getConfigPath() {
+  return `${getConfigDir()}/config.json`;
+}
+function getConfig() {
+  const path = getConfigPath();
+  if (!existsSync2(path)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = readFileSync2(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function setConfig(updates) {
+  const current = getConfig();
+  const merged = { ...current, ...updates };
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(merged, null, 2), "utf-8");
+  return merged;
+}
+function resetConfig() {
+  const path = getConfigPath();
+  writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf-8");
+  return { ...DEFAULT_CONFIG };
+}
+function setConfigValue(key, value) {
+  const config = getConfig();
+  config[key] = value;
+  return setConfig(config);
+}
+
+// src/lib/local/walker.ts
+import { readdirSync, readFileSync as readFileSync3, statSync, openSync, readSync, closeSync } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/local/ignore.ts
+function classEnd(pattern, open) {
+  let i = open + 1;
+  if (pattern[i] === "!")
+    i++;
+  if (pattern[i] === "]")
+    i++;
+  for (;i < pattern.length; i++) {
+    if (pattern[i] === "\\") {
+      i++;
+      continue;
+    }
+    if (pattern[i] === "]")
+      return i;
+  }
+  return -1;
+}
+function globToRegExp(pattern) {
+  let out = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const ch = pattern[i];
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        const segmentStart = i === 0 || pattern[i - 1] === "/";
+        if (segmentStart && pattern[i + 2] === "/") {
+          out += "(?:[^/]*/)*";
+          i += 3;
+        } else if (segmentStart && i + 2 === pattern.length) {
+          out += ".*";
+          i += 2;
+        } else {
+          out += "[^/]*";
+          i += 2;
+        }
+      } else {
+        out += "[^/]*";
+        i += 1;
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+      i += 1;
+    } else if (ch === "[") {
+      const close = classEnd(pattern, i);
+      if (close === -1) {
+        out += "\\[";
+        i += 1;
+      } else {
+        let cls = pattern.slice(i + 1, close);
+        if (cls.startsWith("!"))
+          cls = "^" + cls.slice(1);
+        let jsCls = "";
+        for (let k = 0;k < cls.length; k++) {
+          const c = cls[k];
+          if (c === "\\" && k + 1 < cls.length) {
+            jsCls += "\\" + cls[k + 1];
+            k++;
+          } else if (c === "]") {
+            jsCls += "\\]";
+          } else if (c === "\\") {
+            jsCls += "\\\\";
+          } else {
+            jsCls += c;
+          }
+        }
+        out += `[${jsCls}]`;
+        i = close + 1;
+      }
+    } else if (ch === "\\" && i + 1 < pattern.length) {
+      out += pattern[i + 1].replace(/[.+^${}()|[\]\\*?]/g, "\\$&");
+      i += 2;
+    } else {
+      out += ch.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      i += 1;
+    }
+  }
+  return out;
+}
+function compile(raw) {
+  let pattern = raw.replace(/\r$/, "");
+  if (!pattern.trim() || pattern.startsWith("#"))
+    return null;
+  let negated = false;
+  if (pattern.startsWith("!")) {
+    negated = true;
+    pattern = pattern.slice(1);
+  }
+  pattern = pattern.replace(/(?<!\\) +$/, "");
+  if (!pattern)
+    return null;
+  let dirOnly = false;
+  if (pattern.endsWith("/")) {
+    dirOnly = true;
+    pattern = pattern.slice(0, -1);
+  }
+  const anchored = pattern.includes("/");
+  if (pattern.startsWith("/"))
+    pattern = pattern.slice(1);
+  const body = globToRegExp(pattern);
+  const prefix = anchored ? "^" : "^(?:.*/)?";
+  const regex = new RegExp(`${prefix}${body}$`);
+  return { regex, negated, dirOnly };
+}
+
+class IgnoreMatcher {
+  patterns;
+  base;
+  constructor(lines, base = "") {
+    this.base = base;
+    this.patterns = lines.map(compile).filter((p) => p !== null);
+  }
+  ignores(relPath, isDir) {
+    let local = relPath;
+    if (this.base) {
+      if (!relPath.startsWith(this.base + "/"))
+        return;
+      local = relPath.slice(this.base.length + 1);
+    }
+    let result;
+    for (const p of this.patterns) {
+      if (p.dirOnly && !isDir)
+        continue;
+      if (p.regex.test(local))
+        result = !p.negated;
+    }
+    return result;
+  }
+}
+
+class IgnoreStack {
+  hard;
+  stack = [];
+  constructor(hard = null) {
+    this.hard = hard;
+  }
+  push(matcher) {
+    this.stack.push(matcher);
+  }
+  pop() {
+    this.stack.pop();
+  }
+  ignores(relPath, isDir) {
+    const hardResult = this.hard?.ignores(relPath, isDir);
+    if (hardResult !== undefined)
+      return hardResult;
+    for (let i = this.stack.length - 1;i >= 0; i--) {
+      const result = this.stack[i].ignores(relPath, isDir);
+      if (result !== undefined)
+        return result;
+    }
+    return false;
+  }
+}
+var DEFAULT_EXCLUDES = [
+  ".git/",
+  "node_modules/",
+  "__pycache__/",
+  ".venv/",
+  "venv/",
+  ".tox/",
+  "dist/",
+  "build/",
+  "out/",
+  ".next/",
+  ".nuxt/",
+  ".cache/",
+  ".turbo/",
+  "target/",
+  "coverage/",
+  ".pnpm-store/",
+  ".bun/",
+  ".DS_Store"
+];
+
+// src/lib/local/walker.ts
+var BINARY_EXTENSIONS = new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "ico",
+  "bmp",
+  "tiff",
+  "heic",
+  "pdf",
+  "zip",
+  "gz",
+  "tgz",
+  "tar",
+  "bz2",
+  "xz",
+  "zst",
+  "7z",
+  "rar",
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "a",
+  "o",
+  "obj",
+  "class",
+  "jar",
+  "war",
+  "pyc",
+  "wasm",
+  "node",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "eot",
+  "mp3",
+  "mp4",
+  "m4a",
+  "avi",
+  "mov",
+  "mkv",
+  "webm",
+  "wav",
+  "flac",
+  "ogg",
+  "sqlite",
+  "db",
+  "bin",
+  "dat",
+  "ds_store"
+]);
+var CONTENT_EXCLUDED_NAMES = [/\.lock$/, /-lock\.(json|yaml)$/, /\.min\.(js|css)$/, /\.map$/, /\.svg$/];
+function hasBinaryExtension(ext) {
+  return BINARY_EXTENSIONS.has(ext.toLowerCase());
+}
+function isContentExcluded(name) {
+  return CONTENT_EXCLUDED_NAMES.some((re) => re.test(name));
+}
+function isBinaryFile(absPath) {
+  const buf = Buffer.alloc(8192);
+  let fd;
+  try {
+    fd = openSync(absPath, "r");
+  } catch {
+    return true;
+  }
+  try {
+    const read = readSync(fd, buf, 0, buf.length, 0);
+    for (let i = 0;i < read; i++) {
+      if (buf[i] === 0)
+        return true;
+    }
+    return false;
+  } finally {
+    closeSync(fd);
+  }
+}
+function readGitignore(dirAbs) {
+  try {
+    return readFileSync3(join2(dirAbs, ".gitignore"), "utf-8").split(`
+`);
+  } catch {
+    return null;
+  }
+}
+function extOf(name) {
+  const idx = name.lastIndexOf(".");
+  return idx > 0 ? name.slice(idx + 1).toLowerCase() : "";
+}
+function scanRoot(rootPath, extraExcludes = []) {
+  const stack = new IgnoreStack(new IgnoreMatcher([...DEFAULT_EXCLUDES, ...extraExcludes]));
+  const files = [];
+  const skippedDirs = [];
+  const walk = (dirAbs, dirRel) => {
+    const gitignore = readGitignore(dirAbs);
+    if (gitignore)
+      stack.push(new IgnoreMatcher(gitignore, dirRel));
+    let entries;
+    try {
+      entries = readdirSync(dirAbs, { withFileTypes: true });
+    } catch (err) {
+      if (gitignore)
+        stack.pop();
+      if (dirRel === "") {
+        throw new Error(`Cannot read index root ${dirAbs}: ${err instanceof Error ? err.message : err}`);
+      }
+      if (err.code !== "ENOENT")
+        skippedDirs.push(dirRel);
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink())
+        continue;
+      const relPath = dirRel ? `${dirRel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (entry.name === ".git")
+          continue;
+        if (stack.ignores(relPath, true))
+          continue;
+        walk(join2(dirAbs, entry.name), relPath);
+      } else if (entry.isFile()) {
+        if (stack.ignores(relPath, false))
+          continue;
+        let stat;
+        try {
+          stat = statSync(join2(dirAbs, entry.name));
+        } catch {
+          continue;
+        }
+        files.push({
+          relPath,
+          name: entry.name,
+          ext: extOf(entry.name),
+          dir: dirRel,
+          size: stat.size,
+          mtimeMs: Math.floor(stat.mtimeMs)
+        });
+      }
+    }
+    if (gitignore)
+      stack.pop();
+  };
+  walk(rootPath, "");
+  files.sort((a, b) => a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0);
+  return { files, skippedDirs };
+}
+
+// src/lib/local/indexer.ts
+function rowToRoot(row) {
+  return {
+    id: row.id,
+    path: row.path,
+    name: row.name,
+    exclude: JSON.parse(row.exclude),
+    contentIndexing: Boolean(row.content_indexing),
+    maxFileSize: row.max_file_size,
+    status: row.status,
+    error: row.error,
+    fileCount: row.file_count,
+    lastIndexedAt: row.last_indexed_at,
+    lastDurationMs: row.last_duration_ms,
+    createdAt: row.created_at
+  };
+}
+function normalizeRootPath(path) {
+  const expanded = path === "~" ? homedir2() : path.startsWith("~/") ? `${homedir2()}/${path.slice(2)}` : path;
+  return resolve(expanded.replace(/\/+$/, "") || "/");
+}
+function listRoots(db) {
+  const d = db ?? getIndexDb();
+  const rows = d.query("SELECT * FROM index_roots ORDER BY path").all();
+  return rows.map(rowToRoot);
+}
+function getRoot(ref, db) {
+  const d = db ?? getIndexDb();
+  const row = d.prepare(`SELECT *, CASE WHEN id = $ref THEN 0 WHEN path = $path THEN 1 ELSE 2 END AS priority
+       FROM index_roots
+       WHERE id = $ref OR path = $path OR name = $ref
+       ORDER BY priority LIMIT 1`).get({ $ref: ref, $path: normalizeRootPath(ref) });
+  return row ? rowToRoot(row) : null;
+}
+function hasReadyRoot(db) {
+  const d = db ?? getIndexDb();
+  const row = d.query("SELECT 1 FROM index_roots WHERE status = 'ready' LIMIT 1").get();
+  return row !== null;
+}
+function addRoot(path, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const normalized = normalizeRootPath(path);
+  let stat;
+  try {
+    stat = statSync2(normalized);
+  } catch {
+    throw new Error(`Path does not exist: ${normalized}`);
+  }
+  if (!stat.isDirectory())
+    throw new Error(`Not a directory: ${normalized}`);
+  if (opts.maxFileSize !== undefined && (!Number.isFinite(opts.maxFileSize) || opts.maxFileSize < 1)) {
+    throw new Error("maxFileSize must be a positive number of bytes");
+  }
+  const existing = getRoot(normalized, d);
+  if (existing && existing.path === normalized) {
+    throw new Error(`Root already indexed: ${existing.path} (${existing.id})`);
+  }
+  const name = opts.name ?? basename(normalized);
+  const nameClash = d.prepare("SELECT path FROM index_roots WHERE name = ?").get(name);
+  if (nameClash) {
+    throw new Error(`Root name "${name}" already used by ${nameClash.path} \u2014 pass a different name.`);
+  }
+  const id = generateId();
+  d.prepare(`INSERT INTO index_roots (id, path, name, exclude, content_indexing, max_file_size, status, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, 'pending', ?)`).run(id, normalized, name, JSON.stringify(opts.exclude ?? []), opts.contentIndexing === false ? 0 : 1, opts.maxFileSize ?? 524288, new Date().toISOString());
+  return getRoot(id, d);
+}
+function removeRoot(idOrPath, db) {
+  const d = db ?? getIndexDb();
+  const root = getRoot(idOrPath, d);
+  if (!root)
+    return false;
+  d.exec("BEGIN");
+  try {
+    d.prepare("DELETE FROM file_content_fts WHERE rowid IN (SELECT id FROM files WHERE root_id = ? AND content_indexed = 1)").run(root.id);
+    d.prepare("DELETE FROM index_roots WHERE id = ?").run(root.id);
+    d.exec("COMMIT");
+  } catch (err) {
+    d.exec("ROLLBACK");
+    throw err;
+  }
+  return true;
+}
+function shouldIndexContent(root, file) {
+  return root.contentIndexing && file.size > 0 && file.size <= root.maxFileSize && !hasBinaryExtension(file.ext) && !isContentExcluded(file.name);
+}
+function indexRoot(idOrPath, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const root = getRoot(idOrPath, d);
+  if (!root)
+    throw new Error(`Index root not found: ${idOrPath}`);
+  const start = Date.now();
+  d.prepare("UPDATE index_roots SET status = 'indexing', error = NULL WHERE id = ?").run(root.id);
+  try {
+    const { files: scanned, skippedDirs } = scanRoot(root.path, root.exclude);
+    const now = new Date().toISOString();
+    const existingRows = d.prepare("SELECT id, rel_path, size, mtime_ms, content_indexed FROM files WHERE root_id = ?").all(root.id);
+    const existing = new Map(existingRows.map((r) => [r.rel_path, r]));
+    const insertFile = d.prepare(`INSERT INTO files (root_id, rel_path, name, ext, dir, size, mtime_ms, is_binary, content_indexed, indexed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const updateFile = d.prepare("UPDATE files SET size = ?, mtime_ms = ?, is_binary = ?, content_indexed = ?, indexed_at = ? WHERE id = ?");
+    const deleteFile = d.prepare("DELETE FROM files WHERE id = ?");
+    const insertContent = d.prepare("INSERT INTO file_content_fts (rowid, body) VALUES (?, ?)");
+    const deleteContent = d.prepare("DELETE FROM file_content_fts WHERE rowid = ?");
+    const stats = {
+      rootId: root.id,
+      added: 0,
+      updated: 0,
+      deleted: 0,
+      contentIndexed: 0,
+      fileCount: scanned.length,
+      skippedDirs: skippedDirs.length,
+      durationMs: 0
+    };
+    d.exec("BEGIN");
+    try {
+      const seen = new Set;
+      for (const file of scanned) {
+        seen.add(file.relPath);
+        const prev = existing.get(file.relPath);
+        const changed = !prev || prev.size !== file.size || prev.mtime_ms !== file.mtimeMs;
+        if (prev && !changed && !opts.force)
+          continue;
+        const wantContent = shouldIndexContent(root, file);
+        const absPath = `${root.path}/${file.relPath}`;
+        let isBinary = wantContent ? isBinaryFile(absPath) : hasBinaryExtension(file.ext);
+        let body = null;
+        if (wantContent && !isBinary) {
+          try {
+            body = readFileSync4(absPath, "utf-8");
+          } catch {
+            isBinary = true;
+          }
+        }
+        const contentIndexed = body !== null ? 1 : 0;
+        if (prev) {
+          if (prev.content_indexed)
+            deleteContent.run(prev.id);
+          updateFile.run(file.size, file.mtimeMs, isBinary ? 1 : 0, contentIndexed, now, prev.id);
+          if (body !== null)
+            insertContent.run(prev.id, body);
+          stats.updated++;
+        } else {
+          const inserted = insertFile.run(root.id, file.relPath, file.name, file.ext, file.dir, file.size, file.mtimeMs, isBinary ? 1 : 0, contentIndexed, now);
+          if (body !== null)
+            insertContent.run(Number(inserted.lastInsertRowid), body);
+          stats.added++;
+        }
+        if (contentIndexed)
+          stats.contentIndexed++;
+      }
+      for (const [relPath, row] of existing) {
+        if (seen.has(relPath))
+          continue;
+        if (row.content_indexed)
+          deleteContent.run(row.id);
+        deleteFile.run(row.id);
+        stats.deleted++;
+      }
+      stats.durationMs = Date.now() - start;
+      d.prepare("UPDATE index_roots SET status = 'ready', file_count = ?, last_indexed_at = ?, last_duration_ms = ? WHERE id = ?").run(scanned.length, now, stats.durationMs, root.id);
+      d.exec("COMMIT");
+    } catch (err) {
+      d.exec("ROLLBACK");
+      throw err;
+    }
+    return stats;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    d.prepare("UPDATE index_roots SET status = 'error', error = ? WHERE id = ?").run(message, root.id);
+    throw err;
+  }
+}
+function indexAllRoots(opts = {}, db) {
+  return listRoots(db).map((root) => indexRoot(root.id, opts, db));
+}
+var refreshing = new Set;
+function refreshStaleRoots(staleMinutes, db) {
+  const cutoff = Date.now() - staleMinutes * 60000;
+  const stats = [];
+  for (const root of listRoots(db)) {
+    if (root.status === "indexing" || root.status === "pending")
+      continue;
+    if (root.lastIndexedAt && Date.parse(root.lastIndexedAt) > cutoff)
+      continue;
+    if (refreshing.has(root.id))
+      continue;
+    refreshing.add(root.id);
+    try {
+      stats.push(indexRoot(root.id, {}, db));
+    } catch {} finally {
+      refreshing.delete(root.id);
+    }
+  }
+  return stats;
+}
+function autoRefreshStaleRoots(db) {
+  const config = getConfig();
+  if (!config.indexAutoRefresh)
+    return [];
+  return refreshStaleRoots(config.indexStaleMinutes, db);
+}
+
+// src/lib/local/query.ts
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+
+// src/lib/local/regex.ts
+function extractRegexLiterals(pattern) {
+  const branches = splitTopLevelAlternation(pattern);
+  const result = [];
+  for (const branch of branches) {
+    const literals = extractSequenceLiterals(branch).filter((l) => l.length >= 3);
+    if (literals.length === 0)
+      return null;
+    result.push({ literals });
+  }
+  return result;
+}
+function splitTopLevelAlternation(pattern) {
+  const branches = [];
+  let depth = 0;
+  let inClass = false;
+  let current = "";
+  for (let i = 0;i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "\\") {
+      current += ch + (pattern[i + 1] ?? "");
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (ch === "]")
+        inClass = false;
+      current += ch;
+      continue;
+    }
+    if (ch === "[") {
+      inClass = true;
+      current += ch;
+    } else if (ch === "(") {
+      depth++;
+      current += ch;
+    } else if (ch === ")") {
+      depth--;
+      current += ch;
+    } else if (ch === "|" && depth === 0) {
+      branches.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  branches.push(current);
+  return branches;
+}
+function extractSequenceLiterals(seq) {
+  const literals = [];
+  let run = "";
+  const flush = () => {
+    if (run.length > 0)
+      literals.push(run.toLowerCase());
+    run = "";
+  };
+  let i = 0;
+  while (i < seq.length) {
+    const ch = seq[i];
+    if (ch === "\\") {
+      const next = seq[i + 1];
+      if (next === undefined)
+        break;
+      if (/[a-zA-Z0-9]/.test(next)) {
+        flush();
+        let len = 2;
+        if (next === "x") {
+          len = 4;
+        } else if (next === "u") {
+          if (seq[i + 2] === "{") {
+            const close = seq.indexOf("}", i + 2);
+            len = close === -1 ? 2 : close - i + 1;
+          } else {
+            len = 6;
+          }
+        } else if (next === "c") {
+          len = 3;
+        } else if (next === "k" && seq[i + 2] === "<") {
+          const close = seq.indexOf(">", i + 2);
+          len = close === -1 ? 2 : close - i + 1;
+        } else if ((next === "p" || next === "P") && seq[i + 2] === "{") {
+          const close = seq.indexOf("}", i + 2);
+          len = close === -1 ? 2 : close - i + 1;
+        }
+        i += len;
+        continue;
+      }
+      const q2 = quantifierAt(seq, i + 2);
+      if (q2.optional) {
+        flush();
+      } else {
+        run += next;
+        if (q2.repeats)
+          flush();
+      }
+      i += 2 + q2.length;
+      continue;
+    }
+    if (ch === "(") {
+      const end = findGroupEnd(seq, i);
+      const inner = seq.slice(i + 1, end);
+      const q2 = quantifierAt(seq, end + 1);
+      flush();
+      const isSpecial = inner.startsWith("?") && !inner.startsWith("?:") && !inner.startsWith("?<");
+      const isNamed = inner.startsWith("?<") && !inner.startsWith("?<=") && !inner.startsWith("?<!");
+      const body = inner.startsWith("?:") ? inner.slice(2) : isNamed ? inner.replace(/^\?<[^>]*>/, "") : inner;
+      if (!isSpecial && !q2.optional && !inner.startsWith("?<=") && !inner.startsWith("?<!")) {
+        const groupBranches = splitTopLevelAlternation(body);
+        if (groupBranches.length === 1) {
+          literals.push(...extractSequenceLiterals(body).filter((l) => l.length >= 3));
+        }
+      }
+      i = end + 1 + q2.length;
+      continue;
+    }
+    if (ch === "[") {
+      const end = findClassEnd(seq, i);
+      const q2 = quantifierAt(seq, end + 1);
+      flush();
+      i = end + 1 + q2.length;
+      continue;
+    }
+    if (ch === "." || ch === "^" || ch === "$") {
+      flush();
+      i++;
+      continue;
+    }
+    if (ch === "*" || ch === "?" || ch === "+" || ch === "{") {
+      const q2 = quantifierAt(seq, i);
+      i += Math.max(1, q2.length);
+      continue;
+    }
+    const q = quantifierAt(seq, i + 1);
+    if (q.optional) {
+      flush();
+    } else {
+      run += ch;
+      if (q.repeats)
+        flush();
+    }
+    i += 1 + q.length;
+  }
+  flush();
+  return literals;
+}
+function quantifierAt(seq, pos) {
+  const ch = seq[pos];
+  if (ch === "?")
+    return { length: 1, optional: true, repeats: false };
+  if (ch === "*")
+    return { length: 1, optional: true, repeats: true };
+  if (ch === "+")
+    return { length: 1, optional: false, repeats: true };
+  if (ch === "{") {
+    const end = seq.indexOf("}", pos);
+    if (end === -1)
+      return { length: 0, optional: false, repeats: false };
+    const body = seq.slice(pos + 1, end);
+    const min = parseInt(body, 10);
+    const lazy = seq[end + 1] === "?" ? 1 : 0;
+    return { length: end - pos + 1 + lazy, optional: !(min >= 1), repeats: true };
+  }
+  return { length: 0, optional: false, repeats: false };
+}
+function findGroupEnd(seq, start) {
+  let depth = 0;
+  let inClass = false;
+  for (let i = start;i < seq.length; i++) {
+    const ch = seq[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (inClass) {
+      if (ch === "]")
+        inClass = false;
+      continue;
+    }
+    if (ch === "[")
+      inClass = true;
+    else if (ch === "(")
+      depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0)
+        return i;
+    }
+  }
+  return seq.length - 1;
+}
+function findClassEnd(seq, start) {
+  for (let i = start + 1;i < seq.length; i++) {
+    const ch = seq[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === "]" && i > start + 1)
+      return i;
+  }
+  return seq.length - 1;
+}
+function buildFtsQueryFromRegex(pattern) {
+  const branches = extractRegexLiterals(pattern);
+  if (!branches)
+    return null;
+  const branchExprs = branches.map((b) => {
+    const ands = b.literals.map((l) => l.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "")).filter((l) => l.length >= 3).map((l) => `"${l.replace(/"/g, '""')}"`).join(" AND ");
+    return branches.length > 1 ? `(${ands})` : ands;
+  });
+  if (branchExprs.some((e) => e.length === 0))
+    return null;
+  return branchExprs.join(" OR ");
+}
+function compileSearchRegex(pattern, caseSensitive = false) {
+  return new RegExp(pattern, caseSensitive ? "" : "i");
+}
+
+// src/lib/local/query.ts
+var MAX_LINE_LENGTH = 200;
+var MAX_MATCHES_PER_FILE = 5;
+function tokenize(query) {
+  return query.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").split(/\s+/).filter(Boolean);
+}
+function buildFtsQuery(query) {
+  const tokens = tokenize(query).filter((t) => t.length >= 3);
+  if (tokens.length === 0)
+    return null;
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(" AND ");
+}
+function clampLimit(limit, fallback = 20) {
+  if (limit === undefined || !Number.isFinite(limit))
+    return fallback;
+  return Math.max(1, Math.min(500, Math.floor(limit)));
+}
+function filterClauses(opts, db) {
+  const clauses = [];
+  const params = [];
+  if (opts.root) {
+    const root = getRoot(opts.root, db);
+    if (!root)
+      throw new Error(`Index root not found: ${opts.root}`);
+    clauses.push("r.id = ?");
+    params.push(root.id);
+  }
+  if (opts.ext) {
+    clauses.push("f.ext = ?");
+    params.push(opts.ext.replace(/^\./, "").toLowerCase());
+  }
+  if (opts.dir) {
+    clauses.push("f.dir LIKE ? ESCAPE '\\'");
+    const dir = opts.dir.replace(/^\/|\/$/g, "").replace(/[\\%_]/g, "\\$&");
+    params.push(`%${dir}%`);
+  }
+  return { sql: clauses.length > 0 ? ` AND ${clauses.join(" AND ")}` : "", params };
+}
+function rowToHit(row, score) {
+  return {
+    rootId: row.root_id,
+    rootName: row.root_name,
+    rootPath: row.root_path,
+    relPath: row.rel_path,
+    absPath: `${row.root_path}/${row.rel_path}`,
+    name: row.name,
+    ext: row.ext,
+    dir: row.dir,
+    size: row.size,
+    mtimeMs: row.mtime_ms,
+    isBinary: row.is_binary === 1,
+    score
+  };
+}
+function normalizeForMatch(s) {
+  return s.toLowerCase().replace(/[-_.]+/g, " ").trim();
+}
+var EXACT_NAME_FLOOR = 0.72;
+var PREFIX_NAME_FLOOR = 0.58;
+var CONTENT_MAX_SCORE = 0.65;
+function scoreFileName(query, tokens, row) {
+  const q = query.trim().toLowerCase();
+  const qNorm = normalizeForMatch(query);
+  const name = row.name.toLowerCase();
+  const stem = name.replace(/\.[^.]+$/, "");
+  const nameNorm = normalizeForMatch(row.name);
+  const stemNorm = normalizeForMatch(row.name.replace(/\.[^.]+$/, ""));
+  const relPath = row.rel_path.toLowerCase();
+  let score = 0;
+  let floor = 0;
+  if (name === q || stem === q || nameNorm === qNorm || stemNorm === qNorm) {
+    score += 100;
+    floor = EXACT_NAME_FLOOR;
+  } else if (name.startsWith(q) || stem.startsWith(q) || stemNorm.startsWith(qNorm)) {
+    score += 60;
+    floor = PREFIX_NAME_FLOOR;
+  } else if (name.includes(q) || nameNorm.includes(qNorm)) {
+    score += 40;
+  }
+  for (const token of tokens) {
+    const t = token.toLowerCase();
+    if (name.includes(t))
+      score += 15;
+    else if (relPath.includes(t))
+      score += 5;
+  }
+  const depth = row.rel_path.split("/").length - 1;
+  score -= depth * 2;
+  const age = Date.now() - row.mtime_ms;
+  if (age < 7 * 86400000)
+    score += 10;
+  else if (age < 30 * 86400000)
+    score += 5;
+  return Math.max(floor, Math.max(0, score) / (Math.max(0, score) + 60));
+}
+var CANDIDATE_COLUMNS = `
+  f.id, f.root_id, r.name as root_name, r.path as root_path,
+  f.rel_path, f.name, f.ext, f.dir, f.size, f.mtime_ms, f.is_binary
+`;
+function searchFilePaths(query, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const tokens = tokenize(query);
+  if (tokens.length === 0)
+    return [];
+  const ftsQuery = buildFtsQuery(query);
+  const filters = filterClauses(opts, d);
+  const candidateLimit = Math.max(200, limit * 10);
+  let rows;
+  if (ftsQuery) {
+    rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+         FROM files_fts fts
+         JOIN files f ON f.id = fts.rowid
+         JOIN index_roots r ON r.id = f.root_id
+         WHERE files_fts MATCH ?${filters.sql}
+         ORDER BY bm25(files_fts, 10.0, 1.0)
+         LIMIT ?`).all(ftsQuery, ...filters.params, candidateLimit);
+    const namePattern = `${query.trim().replace(/[\\%_]/g, "\\$&")}%`;
+    const nameRows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+         FROM files f
+         JOIN index_roots r ON r.id = f.root_id
+         WHERE f.name LIKE ? ESCAPE '\\'${filters.sql}
+         ORDER BY length(f.name)
+         LIMIT 100`).all(namePattern, ...filters.params);
+    const seen = new Set(rows.map((row) => row.id));
+    for (const row of nameRows) {
+      if (!seen.has(row.id))
+        rows.push(row);
+    }
+  } else {
+    const likeClauses = tokens.map(() => "f.rel_path LIKE ? ESCAPE '\\'").join(" AND ");
+    const likeParams = tokens.map((t) => `%${t.replace(/[\\%_]/g, "\\$&")}%`);
+    rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+         FROM files f
+         JOIN index_roots r ON r.id = f.root_id
+         WHERE ${likeClauses}${filters.sql}
+         LIMIT ?`).all(...likeParams, ...filters.params, candidateLimit);
+  }
+  const shortTokens = tokens.filter((t) => t.length < 3).map((t) => t.toLowerCase());
+  const filtered = shortTokens.length > 0 ? rows.filter((row) => shortTokens.every((t) => row.rel_path.toLowerCase().includes(t))) : rows;
+  return filtered.map((row) => rowToHit(row, scoreFileName(query, tokens, row))).sort((a, b) => b.score - a.score).filter((hit) => existsSync3(hit.absPath)).slice(0, limit);
+}
+function findLineMatches(content, query, tokens) {
+  const lines = content.split(`
+`);
+  const phrase = query.trim().toLowerCase();
+  const lowered = tokens.map((t) => t.toLowerCase());
+  const phraseHits = [];
+  const allTokenHits = [];
+  const anyTokenHits = [];
+  for (let i = 0;i < lines.length; i++) {
+    const text = lines[i];
+    const lower = text.toLowerCase();
+    const match = { line: i + 1, text: text.trim().slice(0, MAX_LINE_LENGTH) };
+    if (phrase.length > 0 && lower.includes(phrase))
+      phraseHits.push(match);
+    else if (lowered.every((t) => lower.includes(t)))
+      allTokenHits.push(match);
+    else if (lowered.some((t) => t.length >= 3 && lower.includes(t)))
+      anyTokenHits.push(match);
+    if (phraseHits.length >= MAX_MATCHES_PER_FILE)
+      break;
+  }
+  const tier = phraseHits.length > 0 ? "phrase" : allTokenHits.length > 0 ? "all" : "any";
+  const combined = [...phraseHits, ...allTokenHits, ...anyTokenHits];
+  return { matches: combined.slice(0, MAX_MATCHES_PER_FILE), tier };
+}
+function searchFilePathsRegex(pattern, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const regex = compileSearchRegex(pattern, opts.caseSensitive);
+  const ftsQuery = buildFtsQueryFromRegex(pattern);
+  if (!ftsQuery) {
+    throw new Error("Regex pattern needs at least one required literal of 3+ characters (e.g. 'handle.*Click', not '\\w+').");
+  }
+  const filters = filterClauses(opts, d);
+  const rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+       FROM files_fts fts
+       JOIN files f ON f.id = fts.rowid
+       JOIN index_roots r ON r.id = f.root_id
+       WHERE files_fts MATCH ?${filters.sql}
+       ORDER BY fts.rank
+       LIMIT 5000`).all(ftsQuery, ...filters.params);
+  const hits = [];
+  for (const row of rows) {
+    if (!regex.test(row.rel_path) && !regex.test(row.name))
+      continue;
+    const depth = row.rel_path.split("/").length - 1;
+    const score = Math.max(0.05, 0.6 - depth * 0.02);
+    const hit = rowToHit(row, score);
+    if (!existsSync3(hit.absPath))
+      continue;
+    hits.push(hit);
+    if (hits.length >= limit)
+      break;
+  }
+  return hits;
+}
+function searchFileContentRegex(pattern, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const regex = compileSearchRegex(pattern, opts.caseSensitive);
+  const ftsQuery = buildFtsQueryFromRegex(pattern);
+  if (!ftsQuery) {
+    throw new Error("Regex pattern needs at least one required literal of 3+ characters (e.g. 'export.*function', not '\\d+').");
+  }
+  const filters = filterClauses(opts, d);
+  const rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+       FROM file_content_fts fts
+       JOIN files f ON f.id = fts.rowid
+       JOIN index_roots r ON r.id = f.root_id
+       WHERE file_content_fts MATCH ?${filters.sql}
+       ORDER BY fts.rank
+       LIMIT ?`).all(ftsQuery, ...filters.params, Math.max(200, limit * 10));
+  const hits = [];
+  for (let i = 0;i < rows.length && hits.length < limit; i++) {
+    const row = rows[i];
+    const absPath = `${row.root_path}/${row.rel_path}`;
+    let content;
+    try {
+      content = readFileSync5(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const lines = content.split(`
+`);
+    const matches = [];
+    for (let n = 0;n < lines.length && matches.length < MAX_MATCHES_PER_FILE; n++) {
+      if (regex.test(lines[n])) {
+        matches.push({ line: n + 1, text: lines[n].trim().slice(0, MAX_LINE_LENGTH) });
+      }
+    }
+    if (matches.length === 0)
+      continue;
+    const score = Math.max(0.25, 0.65 - i * 0.05);
+    hits.push({
+      ...rowToHit(row, score),
+      line: matches[0].line,
+      lineText: matches[0].text,
+      matches
+    });
+  }
+  return hits;
+}
+function searchFileContent(query, opts = {}, db) {
+  const d = db ?? getIndexDb();
+  const limit = clampLimit(opts.limit);
+  const ftsQuery = buildFtsQuery(query);
+  if (!ftsQuery)
+    return [];
+  const filters = filterClauses(opts, d);
+  const rows = d.prepare(`SELECT ${CANDIDATE_COLUMNS}
+       FROM file_content_fts fts
+       JOIN files f ON f.id = fts.rowid
+       JOIN index_roots r ON r.id = f.root_id
+       WHERE file_content_fts MATCH ?${filters.sql}
+       ORDER BY fts.rank
+       LIMIT ?`).all(ftsQuery, ...filters.params, Math.max(50, limit * 3));
+  const tokens = tokenize(query);
+  const shortTokens = tokens.filter((t) => t.length < 3).map((t) => t.toLowerCase());
+  const scored = [];
+  for (let i = 0;i < rows.length && scored.length < limit * 2; i++) {
+    const row = rows[i];
+    const absPath = `${row.root_path}/${row.rel_path}`;
+    let content;
+    try {
+      content = readFileSync5(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    if (shortTokens.length > 0) {
+      const lower = content.toLowerCase();
+      if (!shortTokens.every((t) => lower.includes(t)))
+        continue;
+    }
+    const { matches, tier } = findLineMatches(content, query, tokens);
+    if (matches.length === 0)
+      continue;
+    const base = Math.max(0.25, 0.55 - i * 0.04);
+    const tierBoost = tier === "phrase" ? 0.1 : tier === "all" ? 0.05 : 0;
+    const score = Math.min(CONTENT_MAX_SCORE, base + tierBoost);
+    scored.push({
+      ...rowToHit(row, score),
+      line: matches[0].line,
+      lineText: matches[0].text,
+      matches
+    });
+  }
+  return scored.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// src/lib/local/find.ts
+function findLocal(query, opts = {}, db) {
+  const kind = opts.kind ?? "both";
+  if (kind !== "file" && kind !== "content" && kind !== "both") {
+    throw new Error(`Invalid kind "${kind}" \u2014 use file, content, or both.`);
+  }
+  const limit = clampLimit(opts.limit);
+  const roots = listRoots(db);
+  if (!hasReadyRoot(db)) {
+    return { query, kind, indexed: false, roots: roots.length, total: 0, results: [] };
+  }
+  if (opts.refresh !== false)
+    autoRefreshStaleRoots(db);
+  const queryOpts = {
+    root: opts.root,
+    ext: opts.ext,
+    dir: opts.dir,
+    limit
+  };
+  const merged = new Map;
+  const pathSearch = opts.regex ? () => searchFilePathsRegex(query, { ...queryOpts, caseSensitive: opts.caseSensitive }, db) : () => searchFilePaths(query, queryOpts, db);
+  const contentSearch = opts.regex ? () => searchFileContentRegex(query, { ...queryOpts, caseSensitive: opts.caseSensitive }, db) : () => searchFileContent(query, queryOpts, db);
+  if (kind === "file" || kind === "both") {
+    for (const hit of pathSearch()) {
+      merged.set(hit.absPath, {
+        path: hit.absPath,
+        root: hit.rootName,
+        kind: "file",
+        score: hit.score,
+        snippet: hit.relPath
+      });
+    }
+  }
+  if (kind === "content" || kind === "both") {
+    for (const hit of contentSearch()) {
+      const existing = merged.get(hit.absPath);
+      if (existing) {
+        existing.kind = "both";
+        existing.score = Math.min(1, Math.max(existing.score, hit.score) + 0.1);
+        existing.line = hit.line;
+        existing.snippet = hit.lineText;
+        existing.matches = hit.matches;
+      } else {
+        merged.set(hit.absPath, {
+          path: hit.absPath,
+          root: hit.rootName,
+          kind: "content",
+          score: hit.score,
+          line: hit.line,
+          snippet: hit.lineText,
+          matches: hit.matches
+        });
+      }
+    }
+  }
+  const results = [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+  return {
+    query,
+    kind,
+    indexed: true,
+    roots: roots.length,
+    total: results.length,
+    results
+  };
+}
+
+// src/cli/local.ts
+function printJson2(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+function parsePositiveInt(value, label) {
+  const n = parseInt(value, 10);
+  if (!Number.isFinite(n) || n < 1) {
+    console.error(chalk2.red(`Invalid ${label}: ${value} (expected a positive number)`));
+    process.exit(1);
+  }
+  return n;
+}
+function printStats(stats, rootLabel) {
+  console.log(chalk2.green(`\u2713 ${rootLabel}`) + chalk2.dim(` ${stats.fileCount} files (+${stats.added} ~${stats.updated} -${stats.deleted}, ${stats.contentIndexed} content) in ${stats.durationMs}ms`));
+}
+function registerLocalCommands(program2) {
+  program2.command("find").description("Find files locally by name, path, or content across indexed roots").argument("<query...>", "What to look for").option("-k, --kind <kind>", "Match kind: file, content, both", "both").option("-r, --root <root>", "Limit to one index root (name, path, or id)").option("-e, --ext <ext>", "Filter by file extension").option("-d, --dir <dir>", "Filter by directory substring").option("-l, --limit <n>", "Max results", "20").option("-x, --regex", "Treat the query as a regular expression (grep-style)").option("--case-sensitive", "Case-sensitive matching (regex mode)").option("--no-refresh", "Skip stale-index refresh before searching").option("--json", "Output as JSON").action((queryParts, opts) => {
+    const query = queryParts.join(" ");
+    let response;
+    try {
+      response = findLocal(query, {
+        kind: opts.kind,
+        root: opts.root,
+        ext: opts.ext,
+        dir: opts.dir,
+        limit: parsePositiveInt(opts.limit, "--limit"),
+        refresh: opts.refresh,
+        regex: opts.regex,
+        caseSensitive: opts.caseSensitive
+      });
+    } catch (err) {
+      console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : err}`));
+      process.exitCode = 1;
+      return;
+    }
+    if (opts.json) {
+      printJson2(response);
+      return;
+    }
+    if (!response.indexed) {
+      console.log(chalk2.yellow("No index roots ready. Add one with: search index add <path>"));
+      process.exitCode = 1;
+      return;
+    }
+    if (response.results.length === 0) {
+      console.log(chalk2.yellow("No matches"));
+      return;
+    }
+    for (const r of response.results) {
+      const loc = r.line ? `:${r.line}` : "";
+      const badge = chalk2.bgCyan.black(` ${r.kind} `);
+      console.log(`${badge} ${chalk2.bold(r.path)}${chalk2.dim(loc)}`);
+      if (r.kind !== "file" && r.snippet)
+        console.log(`   ${r.snippet}`);
+      for (const m of r.matches?.slice(1) ?? []) {
+        console.log(chalk2.dim(`   :${m.line} ${m.text}`));
+      }
+    }
+  });
+  const index = program2.command("index").description("Manage the local file index");
+  index.command("add <path>").description("Register a directory and index it").option("-n, --name <name>", "Friendly root name (default: directory basename)").option("--no-content", "Index file paths only, skip content").option("--exclude <patterns>", "Comma-separated extra exclude patterns (gitignore syntax)").option("--max-file-size <bytes>", "Max file size for content indexing", "524288").option("--json", "Output as JSON").action((path, opts) => {
+    try {
+      const root = addRoot(path, {
+        name: opts.name,
+        contentIndexing: opts.content,
+        exclude: opts.exclude ? opts.exclude.split(",").map((s) => s.trim()) : [],
+        maxFileSize: parsePositiveInt(opts.maxFileSize, "--max-file-size")
+      });
+      if (!opts.json)
+        console.log(chalk2.dim(`Indexing ${root.path} ...`));
+      const stats = indexRoot(root.id);
+      if (opts.json) {
+        printJson2({ root: getRoot(root.id), stats });
+        return;
+      }
+      printStats(stats, root.name);
+    } catch (err) {
+      console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : err}`));
+      process.exitCode = 1;
+    }
+  });
+  index.command("update [path]").description("Incrementally re-index one root, or all roots").option("--force", "Re-read content for all files, not just changed ones").option("--json", "Output as JSON").action((path, opts) => {
+    try {
+      if (path) {
+        const root = getRoot(path);
+        if (!root) {
+          console.error(chalk2.red(`Index root not found: ${path}`));
+          process.exitCode = 1;
+          return;
+        }
+        const stats = indexRoot(root.id, { force: opts.force });
+        if (opts.json)
+          printJson2(stats);
+        else
+          printStats(stats, root.name);
+        return;
+      }
+      const all = indexAllRoots({ force: opts.force });
+      if (opts.json) {
+        printJson2(all);
+        return;
+      }
+      if (all.length === 0) {
+        console.log(chalk2.yellow("No index roots. Add one with: search index add <path>"));
+        return;
+      }
+      const roots = listRoots();
+      for (const stats of all) {
+        printStats(stats, roots.find((r) => r.id === stats.rootId)?.name ?? stats.rootId);
+      }
+    } catch (err) {
+      console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : err}`));
+      process.exitCode = 1;
+    }
+  });
+  index.command("list").alias("ls").description("List index roots").option("--json", "Output as JSON").action((opts) => {
+    const roots = listRoots();
+    if (opts.json) {
+      printJson2(roots);
+      return;
+    }
+    if (roots.length === 0) {
+      console.log(chalk2.yellow("No index roots. Add one with: search index add <path>"));
+      return;
+    }
+    for (const r of roots) {
+      const status = r.status === "ready" ? chalk2.green(r.status) : r.status === "error" ? chalk2.red(r.status) : chalk2.yellow(r.status);
+      console.log(`${chalk2.dim(r.id.substring(0, 8))}  ${chalk2.yellow(r.name.padEnd(20))} ${status.padEnd(8)} ${String(r.fileCount).padStart(7)} files  ${chalk2.dim(r.path)}`);
+      if (r.error)
+        console.log(chalk2.red(`    ${r.error}`));
+    }
+  });
+  index.command("status").description("Show index status and staleness").option("--json", "Output as JSON").action((opts) => {
+    const roots = listRoots();
+    const status = roots.map((r) => ({
+      ...r,
+      staleMinutes: r.lastIndexedAt ? Math.round((Date.now() - Date.parse(r.lastIndexedAt)) / 60000) : null
+    }));
+    if (opts.json) {
+      printJson2(status);
+      return;
+    }
+    if (status.length === 0) {
+      console.log(chalk2.yellow("No index roots. Add one with: search index add <path>"));
+      return;
+    }
+    for (const r of status) {
+      const age = r.staleMinutes === null ? "never indexed" : `indexed ${r.staleMinutes}m ago`;
+      console.log(`${chalk2.yellow(r.name.padEnd(20))} ${r.status.padEnd(8)} ${String(r.fileCount).padStart(7)} files  ${age}  ${chalk2.dim(`(${r.lastDurationMs ?? "?"}ms)`)}`);
+    }
+  });
+  index.command("rm <idOrPath>").alias("remove").description("Remove a root and all its indexed data").action((idOrPath) => {
+    if (removeRoot(idOrPath)) {
+      console.log(chalk2.green("Index root removed"));
+    } else {
+      console.error(chalk2.red(`Index root not found: ${idOrPath}`));
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/lib/providers/google.ts
 class GoogleProvider {
   name = "google";
@@ -12496,6 +14021,62 @@ class ArxivProvider {
   }
 }
 
+// src/lib/providers/files.ts
+class FilesProvider {
+  name = "files";
+  displayName = "Local Files";
+  isConfigured() {
+    return hasReadyRoot();
+  }
+  async search(query, options) {
+    autoRefreshStaleRoots();
+    const hits = searchFilePaths(query, { limit: options?.limit ?? 10 });
+    return hits.map((hit) => ({
+      title: hit.name,
+      url: `file://${hit.absPath}`,
+      snippet: hit.absPath,
+      score: hit.score,
+      publishedAt: new Date(hit.mtimeMs).toISOString(),
+      metadata: {
+        root: hit.rootName,
+        relPath: hit.relPath,
+        dir: hit.dir,
+        ext: hit.ext,
+        size: hit.size,
+        isBinary: hit.isBinary
+      }
+    }));
+  }
+}
+
+// src/lib/providers/content.ts
+class ContentProvider {
+  name = "content";
+  displayName = "Local Content";
+  isConfigured() {
+    return hasReadyRoot();
+  }
+  async search(query, options) {
+    autoRefreshStaleRoots();
+    const hits = searchFileContent(query, { limit: options?.limit ?? 10 });
+    return hits.map((hit) => ({
+      title: hit.name,
+      url: `file://${hit.absPath}`,
+      snippet: `${hit.relPath}:${hit.line}: ${hit.lineText}`,
+      score: hit.score,
+      publishedAt: new Date(hit.mtimeMs).toISOString(),
+      metadata: {
+        root: hit.rootName,
+        relPath: hit.relPath,
+        dir: hit.dir,
+        ext: hit.ext,
+        line: hit.line,
+        matches: hit.matches
+      }
+    }));
+  }
+}
+
 // src/lib/providers/index.ts
 var providerFactories = {
   google: () => new GoogleProvider,
@@ -12509,7 +14090,9 @@ var providerFactories = {
   youtube: () => new YouTubeProvider,
   hackernews: () => new HackerNewsProvider,
   github: () => new GitHubProvider,
-  arxiv: () => new ArxivProvider
+  arxiv: () => new ArxivProvider,
+  files: () => new FilesProvider,
+  content: () => new ContentProvider
 };
 var instanceCache = new Map;
 function getProvider(name) {
@@ -12528,6 +14111,8 @@ function getProvider(name) {
 function normalizeUrl(url) {
   try {
     const u = new URL(url);
+    if (u.protocol === "file:")
+      return url.replace(/\/+$/, "");
     u.hostname = u.hostname.toLowerCase();
     u.pathname = u.pathname.replace(/\/+$/, "") || "/";
     const params = new URLSearchParams(u.search);
@@ -12584,55 +14169,6 @@ function deduplicateResults(results) {
   return deduped;
 }
 
-// src/lib/config.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync3, cpSync as cpSync2 } from "fs";
-function getConfigDir() {
-  const home = Bun.env.HOME ?? "/tmp";
-  const newDir = `${home}/.hasna/search`;
-  const oldDir = `${home}/.open-search`;
-  if (!existsSync3(newDir) && existsSync3(oldDir)) {
-    try {
-      mkdirSync2(`${home}/.hasna`, { recursive: true });
-      cpSync2(oldDir, newDir, { recursive: true });
-    } catch {}
-  }
-  mkdirSync2(newDir, { recursive: true });
-  return newDir;
-}
-function getConfigPath() {
-  return `${getConfigDir()}/config.json`;
-}
-function getConfig() {
-  const path = getConfigPath();
-  if (!existsSync3(path)) {
-    return { ...DEFAULT_CONFIG };
-  }
-  try {
-    const raw = readFileSync2(path, "utf-8");
-    const parsed = JSON.parse(raw);
-    return { ...DEFAULT_CONFIG, ...parsed };
-  } catch {
-    return { ...DEFAULT_CONFIG };
-  }
-}
-function setConfig(updates) {
-  const current = getConfig();
-  const merged = { ...current, ...updates };
-  const path = getConfigPath();
-  writeFileSync(path, JSON.stringify(merged, null, 2), "utf-8");
-  return merged;
-}
-function resetConfig() {
-  const path = getConfigPath();
-  writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2), "utf-8");
-  return { ...DEFAULT_CONFIG };
-}
-function setConfigValue(key, value) {
-  const config = getConfig();
-  config[key] = value;
-  return setConfig(config);
-}
-
 // src/db/searches.ts
 init_database();
 function rowToSearch(row) {
@@ -12865,6 +14401,8 @@ function updateProviderLastUsed(name, db) {
   d.prepare("UPDATE providers SET last_used_at = ? WHERE name = ?").run(now, name);
 }
 function isProviderConfigured(provider) {
+  if (LOCAL_PROVIDER_NAMES.has(provider.name))
+    return hasReadyRoot();
   if (!provider.apiKeyEnv)
     return true;
   return !!Bun.env[provider.apiKeyEnv];
@@ -12890,10 +14428,19 @@ async function unifiedSearch(query, opts = {}) {
       providerNames = dbProviders.filter((p) => p.enabled).map((p) => p.name);
     }
   }
+  const errors2 = [];
+  const explicitRequest = (opts.providers?.length ?? 0) > 0 || Boolean(opts.profile);
   const activeProviders = providerNames.filter((name) => {
     try {
-      const provider = getProvider(name);
-      return provider.isConfigured();
+      if (getProvider(name).isConfigured())
+        return true;
+      if (explicitRequest) {
+        errors2.push({
+          provider: name,
+          error: LOCAL_PROVIDER_NAMES.has(name) ? "no index roots ready \u2014 run `search index add <path>` first" : "not configured (missing API key)"
+        });
+      }
+      return false;
     } catch {
       return false;
     }
@@ -12909,7 +14456,6 @@ async function unifiedSearch(query, opts = {}) {
     return { name, results: rawResults };
   }));
   const allResults = [];
-  const errors2 = [];
   const searchId = generateId();
   for (const result of results) {
     if (result.status === "fulfilled") {
@@ -12950,19 +14496,31 @@ async function unifiedSearch(query, opts = {}) {
     });
   }
   const duration = Date.now() - startTime;
+  if (activeProviders.length === 0) {
+    return {
+      search: {
+        id: searchId,
+        query,
+        providers: [],
+        profileId: null,
+        resultCount: 0,
+        duration,
+        createdAt: new Date().toISOString()
+      },
+      results: finalResults,
+      errors: errors2
+    };
+  }
+  const persistable = config.recordLocalResults ? finalResults : finalResults.filter((r) => !LOCAL_PROVIDER_NAMES.has(r.source));
   const search = createSearch({
     query,
     providers: activeProviders,
-    resultCount: finalResults.length,
+    resultCount: persistable.length,
     duration
   }, db);
-  if (finalResults.length > 0) {
-    const resultsToStore = finalResults.map((r) => ({
-      ...r,
-      searchId: search.id
-    }));
-    createResults(resultsToStore.map((r) => ({
-      searchId: r.searchId,
+  if (persistable.length > 0) {
+    createResults(persistable.map((r) => ({
+      searchId: search.id,
       title: r.title,
       url: r.url,
       snippet: r.snippet,
@@ -12975,7 +14533,7 @@ async function unifiedSearch(query, opts = {}) {
       metadata: r.metadata
     })), db);
   }
-  updateSearchResults(search.id, finalResults.length, duration, db);
+  updateSearchResults(search.id, persistable.length, duration, db);
   return {
     search: { ...search, resultCount: finalResults.length, duration },
     results: finalResults,
@@ -13251,9 +14809,11 @@ function updateSavedSearchLastRun(id, db) {
 }
 
 // src/cli/index.tsx
+var pkg = require_package();
 var program2 = new Command;
-program2.name("search").version("0.0.1").description("Unified search aggregator \u2014 12 providers, one interface");
-registerCloudCommands(program2);
+program2.name("search").version(pkg.version).description("Unified search \u2014 local file index + 12 web providers, one interface");
+registerStorageCommands(program2);
+registerLocalCommands(program2);
 program2.command("query").alias("q").argument("<query...>", "Search query").option("-p, --providers <providers>", "Comma-separated providers").option("--profile <name>", "Use a search profile").option("-l, --limit <n>", "Max results per provider", "10").option("-f, --format <format>", "Output format: table, json", "table").option("--no-dedup", "Disable deduplication").action(async (queryParts, opts) => {
   const query = queryParts.join(" ");
   const providers = opts.providers ? opts.providers.split(",") : undefined;
@@ -13270,7 +14830,7 @@ program2.command("query").alias("q").argument("<query...>", "Search query").opti
     }
     printResults2(response.results, response.search.duration, response.errors);
   } catch (err) {
-    console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : err}`));
+    console.error(chalk3.red(`Error: ${err instanceof Error ? err.message : err}`));
     process.exit(1);
   }
 });
@@ -13285,11 +14845,11 @@ for (const providerName of PROVIDER_NAMES) {
         });
         printResults2(deep.videoResults, 0, []);
         if (deep.transcriptMatches.length > 0) {
-          console.log(chalk2.cyan(`
+          console.log(chalk3.cyan(`
 --- Transcript Matches ---`));
           for (const m of deep.transcriptMatches) {
-            console.log(chalk2.yellow(m.videoTitle));
-            console.log(chalk2.dim(m.snippet));
+            console.log(chalk3.yellow(m.videoTitle));
+            console.log(chalk3.dim(m.snippet));
             console.log();
           }
         }
@@ -13302,7 +14862,7 @@ for (const providerName of PROVIDER_NAMES) {
       }
       printResults2(response.results, response.search.duration, response.errors);
     } catch (err) {
-      console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : err}`));
+      console.error(chalk3.red(`Error: ${err instanceof Error ? err.message : err}`));
       process.exit(1);
     }
   });
@@ -13313,19 +14873,19 @@ history.command("list").alias("ls").option("-l, --limit <n>", "Max items", "20")
     limit: parseInt(opts.limit),
     query: opts.query
   });
-  console.log(chalk2.bold(`Search History (${total} total)`));
+  console.log(chalk3.bold(`Search History (${total} total)`));
   console.log();
   for (const s of searches) {
-    console.log(`${chalk2.dim(s.id.substring(0, 8))}  ${chalk2.white(s.query)}  ${chalk2.cyan(s.providers.join(","))}  ${chalk2.green(String(s.resultCount) + " results")}  ${chalk2.dim(s.createdAt)}`);
+    console.log(`${chalk3.dim(s.id.substring(0, 8))}  ${chalk3.white(s.query)}  ${chalk3.cyan(s.providers.join(","))}  ${chalk3.green(String(s.resultCount) + " results")}  ${chalk3.dim(s.createdAt)}`);
   }
 });
 history.command("show <id>").action((id) => {
   const search = getSearch(id);
   if (!search) {
-    console.error(chalk2.red(`Search not found: ${id}`));
+    console.error(chalk3.red(`Search not found: ${id}`));
     return;
   }
-  console.log(chalk2.bold(`Query: ${search.query}`));
+  console.log(chalk3.bold(`Query: ${search.query}`));
   console.log(`Providers: ${search.providers.join(", ")}`);
   console.log(`Results: ${search.resultCount} | Duration: ${search.duration}ms`);
   console.log();
@@ -13334,32 +14894,32 @@ history.command("show <id>").action((id) => {
 });
 history.command("delete <id>").action((id) => {
   if (deleteSearch(id)) {
-    console.log(chalk2.green("Search deleted"));
+    console.log(chalk3.green("Search deleted"));
   } else {
-    console.error(chalk2.red(`Search not found: ${id}`));
+    console.error(chalk3.red(`Search not found: ${id}`));
   }
 });
 var saved = program2.command("saved").description("Saved searches");
 saved.command("list").alias("ls").action(() => {
   const items = listSavedSearches();
   if (items.length === 0) {
-    console.log(chalk2.dim("No saved searches"));
+    console.log(chalk3.dim("No saved searches"));
     return;
   }
   for (const s of items) {
-    console.log(`${chalk2.dim(s.id.substring(0, 8))}  ${chalk2.yellow(s.name)}  ${chalk2.white(s.query)}  ${chalk2.cyan(s.providers.join(","))}  ${chalk2.dim(s.lastRunAt ?? "never run")}`);
+    console.log(`${chalk3.dim(s.id.substring(0, 8))}  ${chalk3.yellow(s.name)}  ${chalk3.white(s.query)}  ${chalk3.cyan(s.providers.join(","))}  ${chalk3.dim(s.lastRunAt ?? "never run")}`);
   }
 });
 saved.command("add <name> <query...>").option("-p, --providers <providers>", "Comma-separated providers").option("--profile <name>", "Search profile").action((name, queryParts, opts) => {
   const query = queryParts.join(" ");
   const providers = opts.providers ? opts.providers.split(",") : [];
   const s = createSavedSearch({ name, query, providers, profileId: opts.profile });
-  console.log(chalk2.green(`Saved search created: ${s.id}`));
+  console.log(chalk3.green(`Saved search created: ${s.id}`));
 });
 saved.command("run <id>").action(async (id) => {
   const s = getSavedSearch(id);
   if (!s) {
-    console.error(chalk2.red(`Saved search not found: ${id}`));
+    console.error(chalk3.red(`Saved search not found: ${id}`));
     return;
   }
   updateSavedSearchLastRun(id);
@@ -13371,35 +14931,35 @@ saved.command("run <id>").action(async (id) => {
 });
 saved.command("delete <id>").action((id) => {
   if (deleteSavedSearch(id)) {
-    console.log(chalk2.green("Saved search deleted"));
+    console.log(chalk3.green("Saved search deleted"));
   } else {
-    console.error(chalk2.red(`Not found: ${id}`));
+    console.error(chalk3.red(`Not found: ${id}`));
   }
 });
 var providers = program2.command("providers").description("Manage search providers");
 providers.command("list").alias("ls").action(() => {
   const all = listProviders();
-  console.log(chalk2.bold("Search Providers"));
+  console.log(chalk3.bold("Search Providers"));
   console.log();
   for (const p of all) {
     const configured = isProviderConfigured(p);
-    const status = p.enabled ? configured ? chalk2.green("enabled") : chalk2.yellow("enabled (no key)") : chalk2.dim("disabled");
-    const keyInfo = p.apiKeyEnv ? chalk2.dim(` [${p.apiKeyEnv}]`) : chalk2.dim(" [no key needed]");
-    console.log(`  ${chalk2.white(p.name.padEnd(14))} ${status}${keyInfo}  rate: ${p.rateLimit}/min`);
+    const status = p.enabled ? configured ? chalk3.green("enabled") : chalk3.yellow("enabled (no key)") : chalk3.dim("disabled");
+    const keyInfo = p.apiKeyEnv ? chalk3.dim(` [${p.apiKeyEnv}]`) : chalk3.dim(" [no key needed]");
+    console.log(`  ${chalk3.white(p.name.padEnd(14))} ${status}${keyInfo}  rate: ${p.rateLimit}/min`);
   }
 });
 providers.command("enable <name>").action((name) => {
   if (enableProvider(name)) {
-    console.log(chalk2.green(`Provider ${name} enabled`));
+    console.log(chalk3.green(`Provider ${name} enabled`));
   } else {
-    console.error(chalk2.red(`Provider not found: ${name}`));
+    console.error(chalk3.red(`Provider not found: ${name}`));
   }
 });
 providers.command("disable <name>").action((name) => {
   if (disableProvider(name)) {
-    console.log(chalk2.green(`Provider ${name} disabled`));
+    console.log(chalk3.green(`Provider ${name} disabled`));
   } else {
-    console.error(chalk2.red(`Provider not found: ${name}`));
+    console.error(chalk3.red(`Provider not found: ${name}`));
   }
 });
 providers.command("configure <name>").option("--key-env <env>", "API key env var name").option("--rate-limit <n>", "Requests per minute").action((name, opts) => {
@@ -13409,35 +14969,35 @@ providers.command("configure <name>").option("--key-env <env>", "API key env var
   if (opts.rateLimit)
     updates.rateLimit = parseInt(opts.rateLimit);
   if (updateProvider(name, updates)) {
-    console.log(chalk2.green(`Provider ${name} updated`));
+    console.log(chalk3.green(`Provider ${name} updated`));
   } else {
-    console.error(chalk2.red(`Provider not found: ${name}`));
+    console.error(chalk3.red(`Provider not found: ${name}`));
   }
 });
 var profiles = program2.command("profiles").description("Search profiles");
 profiles.command("list").alias("ls").action(() => {
   const all = listProfiles();
   for (const p of all) {
-    console.log(`${chalk2.dim(p.id.substring(0, 12))}  ${chalk2.yellow(p.name.padEnd(12))} ${chalk2.white(p.providers.join(", "))}  ${chalk2.dim(p.description ?? "")}`);
+    console.log(`${chalk3.dim(p.id.substring(0, 12))}  ${chalk3.yellow(p.name.padEnd(12))} ${chalk3.white(p.providers.join(", "))}  ${chalk3.dim(p.description ?? "")}`);
   }
 });
 profiles.command("create <name>").option("-p, --providers <providers>", "Comma-separated providers").option("-d, --description <desc>", "Description").action((name, opts) => {
   const providerList = opts.providers ? opts.providers.split(",") : [];
   const p = createProfile({ name, providers: providerList, description: opts.description });
-  console.log(chalk2.green(`Profile created: ${p.id}`));
+  console.log(chalk3.green(`Profile created: ${p.id}`));
 });
 profiles.command("delete <id>").action((id) => {
   if (deleteProfile(id)) {
-    console.log(chalk2.green("Profile deleted"));
+    console.log(chalk3.green("Profile deleted"));
   } else {
-    console.error(chalk2.red(`Profile not found: ${id}`));
+    console.error(chalk3.red(`Profile not found: ${id}`));
   }
 });
 profiles.command("use <name> <query...>").action(async (name, queryParts) => {
   const query = queryParts.join(" ");
   const profile = getProfileByName(name);
   if (!profile) {
-    console.error(chalk2.red(`Profile not found: ${name}`));
+    console.error(chalk3.red(`Profile not found: ${name}`));
     return;
   }
   const response = await unifiedSearch(query, { profile: name });
@@ -13448,12 +15008,12 @@ program2.command("export <searchId>").option("-f, --format <format>", "Format: j
     const output = exportResults(searchId, opts.format);
     if (opts.output) {
       Bun.write(opts.output, output);
-      console.log(chalk2.green(`Exported to ${opts.output}`));
+      console.log(chalk3.green(`Exported to ${opts.output}`));
     } else {
       console.log(output);
     }
   } catch (err) {
-    console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : err}`));
+    console.error(chalk3.red(`Error: ${err instanceof Error ? err.message : err}`));
   }
 });
 var config = program2.command("config").description("Configuration");
@@ -13473,20 +15033,20 @@ config.command("set <key> <value>").action((key, value) => {
   } catch {
     setConfigValue(key, value);
   }
-  console.log(chalk2.green(`Config ${key} updated`));
+  console.log(chalk3.green(`Config ${key} updated`));
 });
 config.command("reset").action(() => {
   resetConfig();
-  console.log(chalk2.green("Config reset to defaults"));
+  console.log(chalk3.green("Config reset to defaults"));
 });
 program2.command("stats").action(() => {
   const stats = getSearchStats();
-  console.log(chalk2.bold("Search Statistics"));
+  console.log(chalk3.bold("Search Statistics"));
   console.log(`  Total searches: ${stats.totalSearches}`);
   console.log(`  Total results:  ${stats.totalResults}`);
   console.log();
   if (Object.keys(stats.providerBreakdown).length > 0) {
-    console.log(chalk2.bold("  Results by Provider:"));
+    console.log(chalk3.bold("  Results by Provider:"));
     for (const [provider, count] of Object.entries(stats.providerBreakdown)) {
       console.log(`    ${provider.padEnd(14)} ${count}`);
     }
@@ -13494,27 +15054,30 @@ program2.command("stats").action(() => {
 });
 function printResults2(results, duration, errors2) {
   if (results.length === 0) {
-    console.log(chalk2.yellow("No results found"));
+    console.log(chalk3.yellow("No results found"));
+    for (const e of errors2) {
+      console.error(`  ${chalk3.red(e.provider)}: ${e.error}`);
+    }
     return;
   }
-  console.log(chalk2.bold(`${results.length} results`) + chalk2.dim(` (${duration}ms)`));
+  console.log(chalk3.bold(`${results.length} results`) + chalk3.dim(` (${duration}ms)`));
   console.log();
   for (const r of results) {
-    const badge = chalk2.bgCyan.black(` ${r.source} `);
-    console.log(`${chalk2.dim(String(r.rank).padStart(3))} ${badge} ${chalk2.bold.blue(r.title)}`);
-    console.log(`     ${chalk2.dim(r.url)}`);
+    const badge = chalk3.bgCyan.black(` ${r.source} `);
+    console.log(`${chalk3.dim(String(r.rank).padStart(3))} ${badge} ${chalk3.bold.blue(r.title)}`);
+    console.log(`     ${chalk3.dim(r.url)}`);
     if (r.snippet) {
       console.log(`     ${r.snippet.substring(0, 200)}`);
     }
     if (r.score !== null) {
-      console.log(`     ${chalk2.dim(`score: ${r.score.toFixed(3)}`)}`);
+      console.log(`     ${chalk3.dim(`score: ${r.score.toFixed(3)}`)}`);
     }
     console.log();
   }
   if (errors2.length > 0) {
-    console.log(chalk2.yellow("Errors:"));
+    console.log(chalk3.yellow("Errors:"));
     for (const e of errors2) {
-      console.log(`  ${chalk2.red(e.provider)}: ${e.error}`);
+      console.log(`  ${chalk3.red(e.provider)}: ${e.error}`);
     }
   }
 }
@@ -13526,7 +15089,7 @@ program2.action(async (_, cmd) => {
       const response = await unifiedSearch(query);
       printResults2(response.results, response.search.duration, response.errors);
     } catch (err) {
-      console.error(chalk2.red(`Error: ${err instanceof Error ? err.message : err}`));
+      console.error(chalk3.red(`Error: ${err instanceof Error ? err.message : err}`));
       process.exit(1);
     }
   } else {
@@ -13536,8 +15099,8 @@ program2.action(async (_, cmd) => {
 program2.command("feedback <message>").description("Send feedback about this service").option("-e, --email <email>", "Contact email").option("-c, --category <cat>", "Category: bug, feature, general", "general").action(async (message, opts) => {
   const { getDb: getDb2 } = await Promise.resolve().then(() => (init_database(), exports_database));
   const db = getDb2();
-  const pkg = require_package();
-  db.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [message, opts.email || null, opts.category || "general", pkg.version]);
-  console.log(chalk2.green("\u2713") + " Feedback saved. Thank you!");
+  const pkg2 = require_package();
+  db.run("INSERT INTO feedback (message, email, category, version) VALUES (?, ?, ?, ?)", [message, opts.email || null, opts.category || "general", pkg2.version]);
+  console.log(chalk3.green("\u2713") + " Feedback saved. Thank you!");
 });
 program2.parse();