@webneat/codewiki 0.0.1

package/dist/cli/bin.js

@@ -0,0 +1,3183 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all3) => {
+  for (var name in all3)
+    __defProp(target, name, { get: all3[name], enumerable: true });
+};
+
+// src/cli/env.ts
+import { existsSync } from "fs";
+
+// src/internals/context.ts
+import ts from "typescript";
+import { fileURLToPath } from "url";
+import Database from "better-sqlite3";
+import { readFile as readFile2 } from "fs/promises";
+import path, { dirname, join as join2 } from "path";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+
+// src/internals/errors.ts
+import create_errors from "@webneat/errors";
+var err = create_errors({
+  file_outside_project_path: (data) => `File "${data.file_path}" is outside project path "${data.project_path}"`,
+  file_not_found: (data) => `File not found: ${data.path}`,
+  db_error: (data) => `Database error in ${data.operation}: ${data.reason}`,
+  symbol_meta_parse_error: (data) => `Failed to parse symbol metadata for symbol ${data.symbol_id}: ${data.reason}`,
+  exported_symbol_not_found: (data) => `Exported symbol "${data.name}" not found in file with id ${data.file_id}`,
+  module_resolution_failed: (data) => `Failed to resolve module "${data.module}" from "${data.from}"`,
+  exporter_file_not_found: (data) => `Exporter file not found at "${data.path}" for module "${data.module}"`,
+  ast_parse_error: (data) => `AST parsing error in ${data.operation}: ${data.reason}`,
+  config_not_found: (data) => `No config found in database at ${data.db_path}`,
+  config_invalid_node_modules_paths: (data) => `Invalid node_modules_paths stored in database ${data.db_path}: ${data.reason}`,
+  symbol_missing_text: (data) => `Symbol ${data.symbol_id} (${data.name}) has no source text`,
+  symbol_node_not_found: (data) => `Symbol node not found for ${data.name} in ${data.file_path}`,
+  symbol_not_found: (data) => `Symbol "${data.name}" not found in file "${data.path}"`,
+  describe_dependency_failed: (data) => `Failed to describe ${data.package}#${data.name}: ${data.reason}`,
+  // CLI errors
+  could_not_read_file: (data) => `Could not read file ${data.path}: ${data.reason}`,
+  invalid_json: (data) => `Invalid JSON: ${data.reason}`,
+  invalid_config: (data) => `Invalid configuration: ${JSON.stringify(data.errors)}`,
+  invalid_type: (data) => `Invalid entity type: ${data.type}. Must be one of: dependency, symbol, file, directory`
+});
+
+// src/db/migrate.ts
+import { readdir, readFile } from "fs/promises";
+import { join } from "path";
+import { sql as sql2 } from "drizzle-orm";
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  configs: () => configs,
+  directories: () => directories,
+  directories_relations: () => directories_relations,
+  external_dependencies: () => external_dependencies,
+  external_dependencies_relations: () => external_dependencies_relations,
+  external_imports: () => external_imports,
+  external_imports_relations: () => external_imports_relations,
+  files: () => files,
+  files_relations: () => files_relations,
+  imports: () => imports,
+  imports_relations: () => imports_relations,
+  migrations: () => migrations,
+  symbol_external_links: () => symbol_external_links,
+  symbol_external_links_relations: () => symbol_external_links_relations,
+  symbol_internal_links: () => symbol_internal_links,
+  symbol_internal_links_relations: () => symbol_internal_links_relations,
+  symbols: () => symbols,
+  symbols_relations: () => symbols_relations
+});
+import { relations, sql } from "drizzle-orm";
+import { sqliteTable, integer, text, index, uniqueIndex } from "drizzle-orm/sqlite-core";
+var timestamps = {
+  created_at: integer("created_at", { mode: "timestamp" }).default(sql`(unixepoch())`).notNull(),
+  updated_at: integer("updated_at", { mode: "timestamp" }).default(sql`(unixepoch())`).notNull()
+};
+var migrations = sqliteTable("migrations", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  name: text("name").notNull().unique(),
+  created_at: timestamps.created_at
+});
+var configs = sqliteTable("configs", {
+  id: integer("id").primaryKey({ autoIncrement: false }).notNull().default(1),
+  project_path: text("project_path").notNull(),
+  description: text("description"),
+  package_json_path: text("package_json_path"),
+  node_modules_paths: text("node_modules_paths"),
+  ...timestamps
+});
+var directories = sqliteTable(
+  "directories",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    parent_id: integer("parent_id").references(() => directories.id, { onDelete: "cascade" }),
+    path: text("path").notNull().unique(),
+    description: text("description"),
+    state: text("state").$type().notNull().default("to_describe"),
+    error: text("error"),
+    ...timestamps
+  },
+  (table) => ({
+    parent_idx: index("directories_parent_idx").on(table.parent_id),
+    path_idx: index("directories_path_idx").on(table.path),
+    state_idx: index("directories_state_idx").on(table.state)
+  })
+);
+var files = sqliteTable(
+  "files",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    directory_id: integer("directory_id").notNull().references(() => directories.id, { onDelete: "cascade" }),
+    path: text("path").notNull().unique(),
+    hash: text("hash"),
+    description: text("description"),
+    state: text("state").$type().notNull().default("to_scan"),
+    error: text("error"),
+    ...timestamps
+  },
+  (table) => ({
+    directory_idx: index("files_directory_idx").on(table.directory_id),
+    path_idx: index("files_path_idx").on(table.path),
+    hash_idx: index("files_hash_idx").on(table.hash),
+    state_idx: index("files_state_idx").on(table.state)
+  })
+);
+var external_dependencies = sqliteTable(
+  "external_dependencies",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    package: text("package").notNull(),
+    subpath: text("subpath"),
+    name: text("name"),
+    version: text("version"),
+    github_repo: text("github_repo"),
+    is_builtin: integer("is_builtin", { mode: "boolean" }).default(false).notNull(),
+    description: text("description"),
+    state: text("state").$type().notNull().default("to_describe"),
+    error: text("error"),
+    ...timestamps
+  },
+  (table) => ({
+    state_idx: index("external_dependencies_state_idx").on(table.state),
+    package_subpath_name_unique: uniqueIndex("external_dependencies_package_subpath_name_unique").on(table.package, table.subpath, table.name)
+  })
+);
+var external_imports = sqliteTable(
+  "external_imports",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    file_id: integer("file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
+    external_dependency_id: integer("external_dependency_id").notNull().references(() => external_dependencies.id, { onDelete: "cascade" }),
+    alias: text("alias").notNull(),
+    is_dynamic: integer("is_dynamic", { mode: "boolean" }).default(false).notNull(),
+    ...timestamps
+  },
+  (table) => ({
+    file_idx: index("external_imports_file_idx").on(table.file_id),
+    external_dependency_idx: index("external_imports_external_dependency_idx").on(table.external_dependency_id)
+  })
+);
+var imports = sqliteTable(
+  "imports",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    exporter_file_id: integer("exporter_file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
+    importer_file_id: integer("importer_file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
+    symbol_id: integer("symbol_id").references(() => symbols.id, { onDelete: "set null" }),
+    name: text("name").notNull(),
+    alias: text("alias").notNull(),
+    is_dynamic: integer("is_dynamic", { mode: "boolean" }).default(false).notNull(),
+    state: text("state").$type().notNull().default("to_link"),
+    error: text("error"),
+    ...timestamps
+  },
+  (table) => ({
+    exporter_file_idx: index("imports_exporter_file_idx").on(table.exporter_file_id),
+    importer_file_idx: index("imports_importer_file_idx").on(table.importer_file_id),
+    symbol_idx: index("imports_symbol_idx").on(table.symbol_id),
+    state_idx: index("imports_state_idx").on(table.state)
+  })
+);
+var symbols = sqliteTable(
+  "symbols",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    file_id: integer("file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
+    type: text("type").notNull(),
+    // 'function', 'class', 'variable', 'type', 'class_method', 'class_property', 'other'
+    name: text("name").notNull(),
+    text: text("text"),
+    // source code
+    meta: text("meta"),
+    // JSON details
+    description: text("description"),
+    is_exported: integer("is_exported", { mode: "boolean" }).default(false).notNull(),
+    state: text("state").$type().notNull().default("to_link"),
+    error: text("error"),
+    ...timestamps
+  },
+  (table) => ({
+    file_idx: index("symbols_file_idx").on(table.file_id),
+    type_idx: index("symbols_type_idx").on(table.type),
+    name_idx: index("symbols_name_idx").on(table.name),
+    is_exported_idx: index("symbols_is_exported_idx").on(table.is_exported),
+    state_idx: index("symbols_state_idx").on(table.state)
+  })
+);
+var symbol_internal_links = sqliteTable(
+  "symbol_internal_links",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    from_file_id: integer("from_file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
+    to_file_id: integer("to_file_id").notNull().references(() => files.id, { onDelete: "cascade" }),
+    from_symbol_id: integer("from_symbol_id").notNull().references(() => symbols.id, { onDelete: "cascade" }),
+    to_symbol_id: integer("to_symbol_id").notNull().references(() => symbols.id, { onDelete: "cascade" }),
+    state: text("state").$type().notNull().default("pending"),
+    error: text("error"),
+    ...timestamps
+  },
+  (table) => ({
+    from_file_idx: index("symbol_internal_links_from_file_idx").on(table.from_file_id),
+    to_file_idx: index("symbol_internal_links_to_file_idx").on(table.to_file_id),
+    from_symbol_idx: index("symbol_internal_links_from_symbol_idx").on(table.from_symbol_id),
+    to_symbol_idx: index("symbol_internal_links_to_symbol_idx").on(table.to_symbol_id),
+    state_idx: index("symbol_internal_links_state_idx").on(table.state)
+  })
+);
+var symbol_external_links = sqliteTable(
+  "symbol_external_links",
+  {
+    id: integer("id").primaryKey({ autoIncrement: true }),
+    symbol_id: integer("symbol_id").notNull().references(() => symbols.id, { onDelete: "cascade" }),
+    external_import_id: integer("external_import_id").notNull().references(() => external_imports.id, { onDelete: "cascade" }),
+    ...timestamps
+  },
+  (table) => ({
+    symbol_idx: index("symbol_external_links_symbol_idx").on(table.symbol_id),
+    external_import_idx: index("symbol_external_links_external_import_idx").on(table.external_import_id)
+  })
+);
+var directories_relations = relations(directories, ({ one, many }) => ({
+  parent: one(directories, {
+    fields: [directories.parent_id],
+    references: [directories.id],
+    relationName: "subdirectories"
+  }),
+  subdirectories: many(directories, {
+    relationName: "subdirectories"
+  }),
+  files: many(files)
+}));
+var files_relations = relations(files, ({ one, many }) => ({
+  directory: one(directories, {
+    fields: [files.directory_id],
+    references: [directories.id]
+  }),
+  external_imports: many(external_imports),
+  imports_as_exporter: many(imports, {
+    relationName: "imports_as_exporter"
+  }),
+  imports_as_importer: many(imports, {
+    relationName: "imports_as_importer"
+  }),
+  symbols: many(symbols),
+  internal_links_from: many(symbol_internal_links, {
+    relationName: "file_internal_links_from"
+  }),
+  internal_links_to: many(symbol_internal_links, {
+    relationName: "file_internal_links_to"
+  })
+}));
+var external_dependencies_relations = relations(external_dependencies, ({ many }) => ({
+  imports: many(external_imports),
+  symbol_external_links: many(symbol_external_links)
+}));
+var external_imports_relations = relations(external_imports, ({ one }) => ({
+  file: one(files, {
+    fields: [external_imports.file_id],
+    references: [files.id]
+  }),
+  external_dependency: one(external_dependencies, {
+    fields: [external_imports.external_dependency_id],
+    references: [external_dependencies.id]
+  })
+}));
+var imports_relations = relations(imports, ({ one }) => ({
+  exporter_file: one(files, {
+    fields: [imports.exporter_file_id],
+    references: [files.id],
+    relationName: "imports_as_exporter"
+  }),
+  importer_file: one(files, {
+    fields: [imports.importer_file_id],
+    references: [files.id],
+    relationName: "imports_as_importer"
+  }),
+  symbol: one(symbols, {
+    fields: [imports.symbol_id],
+    references: [symbols.id]
+  })
+}));
+var symbols_relations = relations(symbols, ({ one, many }) => ({
+  file: one(files, {
+    fields: [symbols.file_id],
+    references: [files.id]
+  }),
+  imports: many(imports),
+  internal_links_from: many(symbol_internal_links, {
+    relationName: "internal_links_from"
+  }),
+  internal_links_to: many(symbol_internal_links, {
+    relationName: "internal_links_to"
+  }),
+  external_links: many(symbol_external_links)
+}));
+var symbol_internal_links_relations = relations(symbol_internal_links, ({ one }) => ({
+  from_file: one(files, {
+    fields: [symbol_internal_links.from_file_id],
+    references: [files.id],
+    relationName: "file_internal_links_from"
+  }),
+  to_file: one(files, {
+    fields: [symbol_internal_links.to_file_id],
+    references: [files.id],
+    relationName: "file_internal_links_to"
+  }),
+  from_symbol: one(symbols, {
+    fields: [symbol_internal_links.from_symbol_id],
+    references: [symbols.id],
+    relationName: "internal_links_from"
+  }),
+  to_symbol: one(symbols, {
+    fields: [symbol_internal_links.to_symbol_id],
+    references: [symbols.id],
+    relationName: "internal_links_to"
+  })
+}));
+var symbol_external_links_relations = relations(symbol_external_links, ({ one }) => ({
+  symbol: one(symbols, {
+    fields: [symbol_external_links.symbol_id],
+    references: [symbols.id]
+  }),
+  external_import: one(external_imports, {
+    fields: [symbol_external_links.external_import_id],
+    references: [external_imports.id]
+  })
+}));
+
+// src/db/migrate.ts
+async function migrate(ctx) {
+  const [migration_filenames, applied_migration_names] = await Promise.all([get_migration_filenames(ctx), get_applied_migration_names(ctx)]);
+  for (const filename of migration_filenames) {
+    if (applied_migration_names.has(filename)) continue;
+    await apply_migration(ctx, filename);
+  }
+}
+async function get_migration_filenames({ migrations_path }) {
+  const filenames = /* @__PURE__ */ new Set();
+  for (const entry of await readdir(migrations_path, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".sql")) continue;
+    filenames.add(entry.name);
+  }
+  return filenames;
+}
+async function get_applied_migration_names({ db: db6 }) {
+  const res = db6.get(sql2`SELECT name FROM sqlite_master WHERE type='table' AND name='migrations'`);
+  if (!res) return /* @__PURE__ */ new Set();
+  const applied = await db6.select({ name: migrations.name }).from(migrations);
+  return new Set(applied.map((x) => x.name));
+}
+async function apply_migration({ sqlite, migrations_path }, filename) {
+  const file_path = join(migrations_path, filename);
+  const queries = await readFile(file_path, "utf-8");
+  sqlite.transaction(() => {
+    sqlite.exec(queries);
+    sqlite.prepare("INSERT INTO migrations (name) VALUES (?)").run(filename);
+  })();
+}
+
+// src/db/configs.ts
+var configs_exports = {};
+__export(configs_exports, {
+  get: () => get,
+  upsert: () => upsert
+});
+import { eq as eq2, sql as sql3 } from "drizzle-orm";
+
+// src/db/common.ts
+import { eq, like, or, and, asc, desc } from "drizzle-orm";
+function safe_query(operation, fn) {
+  return err.safe(fn, (reason, ...args) => err.new("db_error", { operation, args: args.slice(1), reason }));
+}
+function do_search(db6, table, options) {
+  if (!options.select.includes("id")) options.select.push("id");
+  return db6.select(fields(table, options.select)).from(table).where(conditions(table, options.where)).orderBy(order(table, options.order_by)).offset(options.offset).limit(options.limit).all();
+}
+function fields(table, fields2) {
+  const res = {};
+  for (const field of fields2) res[field] = table[field];
+  return res;
+}
+function conditions(table, filters) {
+  if (!filters || Object.keys(filters).length === 0) return void 0;
+  const parts = [];
+  for (const [field, value] of Object.entries(filters)) {
+    if (Array.isArray(value) && value.length > 0) {
+      const field_conditions = value.map((v) => condition(table, field, v));
+      parts.push(or(...field_conditions));
+    } else {
+      parts.push(condition(table, field, value));
+    }
+  }
+  return and(...parts);
+}
+function condition(table, field, value) {
+  if (typeof value === "object" && value !== null) {
+    if ("contains" in value) return like(table[field], `%${value.contains}%`);
+    if ("starts_with" in value) return like(table[field], `${value.starts_with}%`);
+    if ("ends_with" in value) return like(table[field], `%${value.ends_with}`);
+    return eq(table[field], JSON.stringify(value));
+  }
+  return eq(table[field], value);
+}
+function order(table, [field, direction]) {
+  return direction === "asc" ? asc(table[field]) : desc(table[field]);
+}
+
+// src/db/configs.ts
+var get = safe_query(
+  "configs.get",
+  (ctx) => ctx.db.select().from(configs).where(eq2(configs.id, 1)).get()
+);
+var upsert = safe_query(
+  "configs.upsert",
+  (ctx, data) => ctx.db.insert(configs).values({ id: 1, ...data }).onConflictDoUpdate({
+    target: configs.id,
+    set: { ...data, updated_at: sql3`(unixepoch())` }
+  }).run()
+);
+
+// src/db/files.ts
+var files_exports = {};
+__export(files_exports, {
+  all: () => all,
+  by_directory_path: () => by_directory_path,
+  by_id: () => by_id,
+  by_id_and_state: () => by_id_and_state,
+  by_path: () => by_path,
+  by_state: () => by_state,
+  del: () => del,
+  del_by_dir: () => del_by_dir,
+  get_directory_ids: () => get_directory_ids,
+  imported_by: () => imported_by,
+  importing: () => importing,
+  insert: () => insert,
+  search: () => search,
+  update: () => update,
+  update_many: () => update_many,
+  using_dependency: () => using_dependency
+});
+import { eq as eq3, and as and2, inArray, or as or2, like as like2 } from "drizzle-orm";
+
+// src/internals/utils.ts
+import { readFileSync } from "fs";
+var parse_json = err.safe(JSON.parse, (reason, text2) => err.new("invalid_json", { reason, text: text2 }));
+var read_file = err.safe(
+  (path6) => readFileSync(path6, "utf-8"),
+  (reason, path6) => err.new("could_not_read_file", { path: path6, reason })
+);
+function group_by_unique(items, key) {
+  const groups = {};
+  for (const item of items) {
+    groups[key(item)] = item;
+  }
+  return groups;
+}
+function expand({ items, get_children, get_key }) {
+  const visited = /* @__PURE__ */ new Set();
+  const result = [];
+  const queue = [...items];
+  while (queue.length > 0) {
+    const item = queue.shift();
+    const key = get_key(item);
+    if (err.any(key)) return key;
+    if (visited.has(key)) continue;
+    visited.add(key);
+    result.push(item);
+    const children3 = get_children(item);
+    if (err.any(children3)) return children3;
+    queue.push(...children3);
+  }
+  return result;
+}
+function uniq(items) {
+  return [...new Set(items)];
+}
+function merge(a, b) {
+  const res = { ...a };
+  for (const key of Object.keys(b)) {
+    if (b[key] !== void 0) res[key] = b[key];
+  }
+  return res;
+}
+
+// src/db/defaults.ts
+var files2 = {
+  select: ["id", "directory_id", "path", "state", "error"],
+  order_by: ["id", "asc"],
+  limit: 20,
+  offset: 0,
+  where: {}
+};
+var directories2 = {
+  select: ["id", "parent_id", "path", "state", "error"],
+  order_by: ["id", "asc"],
+  limit: 20,
+  offset: 0,
+  where: {}
+};
+var symbols2 = {
+  select: ["id", "file_id", "type", "name", "meta", "is_exported", "state", "error"],
+  order_by: ["id", "asc"],
+  limit: 20,
+  offset: 0,
+  where: {}
+};
+var external_dependencies2 = {
+  select: ["id", "package", "subpath", "name", "state", "error"],
+  order_by: ["id", "asc"],
+  limit: 20,
+  offset: 0,
+  where: {}
+};
+
+// src/db/files.ts
+var default_select_fields = ["id", "directory_id", "path", "state", "error"];
+var all = safe_query("files.all", (ctx) => ctx.db.select().from(files).all());
+var search = safe_query("files.search", (ctx, options = {}) => {
+  return do_search(ctx.db, files, merge(files2, options));
+});
+var by_id = safe_query("files.by_id", (ctx, id) => ctx.db.select().from(files).where(eq3(files.id, id)).get());
+var by_path = safe_query(
+  "files.by_path",
+  (ctx, path6) => ctx.db.select().from(files).where(eq3(files.path, path6)).get()
+);
+var by_state = safe_query(
+  "files.by_state",
+  (ctx, state) => ctx.db.select().from(files).where(eq3(files.state, state)).all()
+);
+var insert = safe_query("files.insert", (ctx, values) => ctx.db.insert(files).values(values).run());
+var update = safe_query(
+  "files.update",
+  (ctx, file_id, values) => ctx.db.update(files).set(values).where(eq3(files.id, file_id)).run()
+);
+var update_many = safe_query(
+  "files.update_many",
+  (ctx, file_ids, values) => ctx.db.update(files).set(values).where(inArray(files.id, file_ids)).run()
+);
+var by_id_and_state = safe_query(
+  "files.by_id_and_state",
+  (ctx, params) => ctx.db.select().from(files).where(and2(eq3(files.id, params.id), eq3(files.state, params.state))).get()
+);
+var del = safe_query("files.delete", (ctx, file_id) => ctx.db.delete(files).where(eq3(files.id, file_id)).run());
+var del_by_dir = safe_query(
+  "files.delete_by_dir",
+  (ctx, directory_id) => ctx.db.delete(files).where(eq3(files.directory_id, directory_id)).run()
+);
+var get_directory_ids = safe_query(
+  "files.get_directory_ids",
+  (ctx, file_ids) => ctx.db.select({ directory_id: files.directory_id }).from(files).where(inArray(files.id, file_ids)).all().map((x) => x.directory_id)
+);
+var by_directory_path = safe_query("files.by_directory_path", (ctx, dir_path, recursive = false) => {
+  let dir_ids;
+  if (recursive) {
+    if (dir_path === "/") {
+      dir_ids = ctx.db.select({ id: directories.id }).from(directories).all().map((d) => d.id);
+    } else {
+      dir_ids = ctx.db.select({ id: directories.id }).from(directories).where(or2(eq3(directories.path, dir_path), like2(directories.path, `${dir_path}/%`))).all().map((d) => d.id);
+    }
+  } else {
+    const dir = ctx.db.select({ id: directories.id }).from(directories).where(eq3(directories.path, dir_path)).get();
+    dir_ids = dir ? [dir.id] : [];
+  }
+  if (dir_ids.length === 0) return [];
+  return ctx.db.select().from(files).where(inArray(files.directory_id, dir_ids)).all();
+});
+var using_dependency = safe_query(
+  "files.using_dependency",
+  (ctx, external_dependency_id, fields_to_select = default_select_fields) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const imports2 = ctx.db.select({ file_id: external_imports.file_id }).from(external_imports).where(eq3(external_imports.external_dependency_id, external_dependency_id)).all();
+    const file_ids = uniq(imports2.map((i) => i.file_id));
+    if (file_ids.length === 0) return [];
+    return ctx.db.select(fields(files, fields_to_select)).from(files).where(inArray(files.id, file_ids)).all();
+  }
+);
+var imported_by = safe_query(
+  "files.imported_by",
+  (ctx, file_id, fields_to_select = default_select_fields) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const import_rows = ctx.db.select({ id: imports.exporter_file_id }).from(imports).where(eq3(imports.importer_file_id, file_id)).all();
+    const file_ids = uniq(import_rows.map((i) => i.id));
+    if (file_ids.length === 0) return [];
+    return ctx.db.select(fields(files, fields_to_select)).from(files).where(inArray(files.id, file_ids)).all();
+  }
+);
+var importing = safe_query(
+  "files.importing",
+  (ctx, file_id, fields_to_select = default_select_fields) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const import_records = ctx.db.select({ importer_file_id: imports.importer_file_id }).from(imports).where(eq3(imports.exporter_file_id, file_id)).all();
+    const file_ids = uniq(import_records.map((i) => i.importer_file_id));
+    if (file_ids.length === 0) return [];
+    return ctx.db.select(fields(files, fields_to_select)).from(files).where(inArray(files.id, file_ids)).all();
+  }
+);
+
+// src/db/directories.ts
+var directories_exports = {};
+__export(directories_exports, {
+  by_id: () => by_id2,
+  by_id_and_state: () => by_id_and_state2,
+  by_path: () => by_path2,
+  by_state: () => by_state2,
+  insert: () => insert2,
+  search: () => search2,
+  update: () => update2,
+  update_many: () => update_many2
+});
+import { eq as eq4, and as and3, inArray as inArray2 } from "drizzle-orm";
+var by_id2 = safe_query(
+  "directories.by_id",
+  (ctx, id) => ctx.db.select().from(directories).where(eq4(directories.id, id)).get()
+);
+var by_path2 = safe_query(
+  "directories.by_path",
+  (ctx, path6) => ctx.db.select().from(directories).where(eq4(directories.path, path6)).get()
+);
+var by_state2 = safe_query(
+  "directories.by_state",
+  (ctx, state) => ctx.db.select().from(directories).where(eq4(directories.state, state)).all()
+);
+var insert2 = safe_query(
+  "directories.insert",
+  (ctx, values) => ctx.db.insert(directories).values(values).returning().get()
+);
+var update2 = safe_query(
+  "directories.update",
+  (ctx, id, values) => ctx.db.update(directories).set(values).where(eq4(directories.id, id)).run()
+);
+var update_many2 = safe_query(
+  "directories.update_many",
+  (ctx, ids, values) => ctx.db.update(directories).set(values).where(inArray2(directories.id, ids)).run()
+);
+var by_id_and_state2 = safe_query(
+  "directories.by_id_and_state",
+  (ctx, params) => ctx.db.select().from(directories).where(and3(eq4(directories.id, params.id), eq4(directories.state, params.state))).get()
+);
+var search2 = safe_query("directories.search", (ctx, options = {}) => {
+  return do_search(ctx.db, directories, merge(directories2, options));
+});
+
+// src/db/imports.ts
+var imports_exports = {};
+__export(imports_exports, {
+  by_exporter_file: () => by_exporter_file,
+  by_importer_file: () => by_importer_file,
+  by_state: () => by_state3,
+  del_by_importer_file: () => del_by_importer_file,
+  insert_many: () => insert_many,
+  update: () => update3
+});
+import { eq as eq5 } from "drizzle-orm";
+var by_exporter_file = safe_query(
+  "imports.by_exporter_file",
+  (ctx, exporter_file_id) => ctx.db.select().from(imports).where(eq5(imports.exporter_file_id, exporter_file_id)).all()
+);
+var by_importer_file = safe_query(
+  "imports.by_importer_file",
+  (ctx, importer_file_id) => ctx.db.select().from(imports).where(eq5(imports.importer_file_id, importer_file_id)).all()
+);
+var insert_many = safe_query("imports.insert_many", (ctx, values) => ctx.db.insert(imports).values(values).run());
+var del_by_importer_file = safe_query(
+  "imports.del_by_importer_file",
+  (ctx, file_id) => ctx.db.delete(imports).where(eq5(imports.importer_file_id, file_id)).run()
+);
+var by_state3 = safe_query(
+  "imports.by_state",
+  (ctx, state) => ctx.db.select().from(imports).where(eq5(imports.state, state)).all()
+);
+var update3 = safe_query(
+  "imports.update",
+  (ctx, id, data) => ctx.db.update(imports).set(data).where(eq5(imports.id, id)).run()
+);
+
+// src/db/symbols.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  by_file: () => by_file,
+  by_file_and_name: () => by_file_and_name,
+  by_id: () => by_id3,
+  by_id_and_state: () => by_id_and_state3,
+  by_state: () => by_state4,
+  del_by_file: () => del_by_file,
+  insert_many: () => insert_many2,
+  meta: () => meta,
+  referenced_by: () => referenced_by,
+  referencing: () => referencing,
+  search: () => search3,
+  update: () => update4,
+  using_dependency: () => using_dependency2
+});
+import { eq as eq6, and as and4, inArray as inArray3 } from "drizzle-orm";
+var insert_many2 = safe_query("symbols.insert_many", (ctx, values) => ctx.db.insert(symbols).values(values).run());
+var del_by_file = safe_query(
+  "symbols.delete_by_file",
+  (ctx, file_id) => ctx.db.delete(symbols).where(eq6(symbols.file_id, file_id)).run()
+);
+var by_file_and_name = safe_query(
+  "symbols.by_file_and_name",
+  (ctx, params) => ctx.db.select().from(symbols).where(and4(eq6(symbols.file_id, params.file_id), eq6(symbols.name, params.name), eq6(symbols.is_exported, params.is_exported))).get()
+);
+var by_state4 = safe_query(
+  "symbols.by_state",
+  (ctx, state) => ctx.db.select().from(symbols).where(eq6(symbols.state, state)).all()
+);
+var by_file = safe_query(
+  "symbols.by_file",
+  (ctx, file_id) => ctx.db.select().from(symbols).where(eq6(symbols.file_id, file_id)).all()
+);
+var update4 = safe_query(
+  "symbols.update",
+  (ctx, id, data) => ctx.db.update(symbols).set(data).where(eq6(symbols.id, id)).run()
+);
+var by_id3 = safe_query("symbols.by_id", (ctx, id) => ctx.db.select().from(symbols).where(eq6(symbols.id, id)).get());
+var by_id_and_state3 = safe_query(
+  "symbols.by_id_and_state",
+  (ctx, params) => ctx.db.select().from(symbols).where(and4(eq6(symbols.id, params.id), eq6(symbols.state, params.state))).get()
+);
+function meta(symbol) {
+  return err.catch(
+    () => JSON.parse(symbol.meta),
+    (reason) => err.new("symbol_meta_parse_error", { reason, symbol_id: symbol.id, meta: symbol.meta })
+  );
+}
+var search3 = safe_query("symbols.search", (ctx, options = {}) => {
+  return do_search(ctx.db, symbols, merge(symbols2, options));
+});
+var referenced_by = safe_query(
+  "symbols.referenced_by",
+  (ctx, symbol_id, fields_to_select = symbols2.select) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const link_records = ctx.db.select({ id: symbol_internal_links.to_symbol_id }).from(symbol_internal_links).where(eq6(symbol_internal_links.from_symbol_id, symbol_id)).all();
+    const symbol_ids = uniq(link_records.map((i) => i.id).filter((id) => id !== null));
+    if (symbol_ids.length === 0) return [];
+    return ctx.db.select(fields(symbols, fields_to_select)).from(symbols).where(inArray3(symbols.id, symbol_ids)).all();
+  }
+);
+var referencing = safe_query(
+  "symbols.referencing",
+  (ctx, symbol_id, fields_to_select = symbols2.select) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const link_records = ctx.db.select({ id: symbol_internal_links.from_symbol_id }).from(symbol_internal_links).where(eq6(symbol_internal_links.to_symbol_id, symbol_id)).all();
+    const symbol_ids = uniq(link_records.map((i) => i.id).filter((id) => id !== null));
+    if (symbol_ids.length === 0) return [];
+    return ctx.db.select(fields(symbols, fields_to_select)).from(symbols).where(inArray3(symbols.id, symbol_ids)).all();
+  }
+);
+var using_dependency2 = safe_query(
+  "symbols.using_dependency",
+  (ctx, dependency_id, fields_to_select = symbols2.select) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const link_records = ctx.db.select({ symbol_id: symbol_external_links.symbol_id }).from(symbol_external_links).innerJoin(external_imports, eq6(symbol_external_links.external_import_id, external_imports.id)).where(eq6(external_imports.external_dependency_id, dependency_id)).all();
+    const symbol_ids = uniq(link_records.map((i) => i.symbol_id));
+    if (symbol_ids.length === 0) return [];
+    return ctx.db.select(fields(symbols, fields_to_select)).from(symbols).where(inArray3(symbols.id, symbol_ids)).all();
+  }
+);
+
+// src/db/external_dependencies.ts
+var external_dependencies_exports = {};
+__export(external_dependencies_exports, {
+  all: () => all2,
+  by_id: () => by_id4,
+  by_package_subpath_and_name: () => by_package_subpath_and_name,
+  by_state: () => by_state5,
+  get_or_create: () => get_or_create,
+  insert: () => insert3,
+  search: () => search4,
+  update: () => update5,
+  used_by_file: () => used_by_file,
+  used_by_symbol: () => used_by_symbol
+});
+import { eq as eq7, and as and5, sql as sql4, inArray as inArray4 } from "drizzle-orm";
+var by_id4 = safe_query(
+  "external_dependencies.by_id",
+  (ctx, id) => ctx.db.select().from(external_dependencies).where(eq7(external_dependencies.id, id)).get()
+);
+var by_state5 = safe_query(
+  "external_dependencies.by_state",
+  (ctx, state) => ctx.db.select().from(external_dependencies).where(eq7(external_dependencies.state, state)).all()
+);
+var by_package_subpath_and_name = safe_query(
+  "external_dependencies.by_package_subpath_and_name",
+  (ctx, params) => ctx.db.select().from(external_dependencies).where(
+    and5(
+      eq7(external_dependencies.package, params.package),
+      params.subpath === null ? sql4`${external_dependencies.subpath} IS NULL` : eq7(external_dependencies.subpath, params.subpath),
+      params.name === null ? sql4`${external_dependencies.name} IS NULL` : eq7(external_dependencies.name, params.name)
+    )
+  ).get()
+);
+var insert3 = safe_query(
+  "external_dependencies.insert",
+  (ctx, value) => ctx.db.insert(external_dependencies).values(value).returning().get()
+);
+var update5 = safe_query(
+  "external_dependencies.update",
+  (ctx, id, data) => ctx.db.update(external_dependencies).set(data).where(eq7(external_dependencies.id, id)).run()
+);
+var all2 = safe_query("external_dependencies.all", (ctx) => ctx.db.select().from(external_dependencies).all());
+function get_or_create(ctx, value) {
+  return err.pipe(
+    () => by_package_subpath_and_name(ctx, { package: value.package, subpath: value.subpath ?? null, name: value.name ?? null }),
+    (existing) => existing || insert3(ctx, value)
+  );
+}
+var search4 = safe_query(
+  "external_dependencies.search",
+  (ctx, options = {}) => {
+    return do_search(ctx.db, external_dependencies, merge(external_dependencies2, options));
+  }
+);
+var used_by_file = safe_query(
+  "external_dependencies.used_by_file",
+  (ctx, file_id, fields_to_select = external_dependencies2.select) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const imports_records = ctx.db.select({ external_dependency_id: external_imports.external_dependency_id }).from(external_imports).where(eq7(external_imports.file_id, file_id)).all();
+    const dependency_ids = uniq(imports_records.map((r) => r.external_dependency_id));
+    if (dependency_ids.length === 0) return [];
+    return ctx.db.select(fields(external_dependencies, fields_to_select)).from(external_dependencies).where(inArray4(external_dependencies.id, dependency_ids)).all();
+  }
+);
+var used_by_symbol = safe_query(
+  "external_dependencies.used_by_symbol",
+  (ctx, symbol_id, fields_to_select = external_dependencies2.select) => {
+    if (!fields_to_select.includes("id")) fields_to_select.push("id");
+    const link_records = ctx.db.select({ external_import_id: symbol_external_links.external_import_id }).from(symbol_external_links).where(eq7(symbol_external_links.symbol_id, symbol_id)).all();
+    if (link_records.length === 0) return [];
+    const external_import_ids = uniq(link_records.map((r) => r.external_import_id));
+    const imports_records = ctx.db.select({ external_dependency_id: external_imports.external_dependency_id }).from(external_imports).where(inArray4(external_imports.id, external_import_ids)).all();
+    const dependency_ids = uniq(imports_records.map((r) => r.external_dependency_id));
+    if (dependency_ids.length === 0) return [];
+    return ctx.db.select(fields(external_dependencies, fields_to_select)).from(external_dependencies).where(inArray4(external_dependencies.id, dependency_ids)).all();
+  }
+);
+
+// src/db/external_imports.ts
+var external_imports_exports = {};
+__export(external_imports_exports, {
+  by_external_dependency: () => by_external_dependency,
+  by_file: () => by_file2,
+  by_symbol: () => by_symbol,
+  del_by_file: () => del_by_file2,
+  insert_many: () => insert_many3
+});
+import { eq as eq8 } from "drizzle-orm";
+var insert_many3 = safe_query(
+  "external_imports.insert_many",
+  (ctx, values) => ctx.db.insert(external_imports).values(values).run()
+);
+var del_by_file2 = safe_query(
+  "external_imports.delete_by_file",
+  (ctx, file_id) => ctx.db.delete(external_imports).where(eq8(external_imports.file_id, file_id)).run()
+);
+var by_file2 = safe_query(
+  "external_imports.by_file",
+  (ctx, file_id) => ctx.db.select().from(external_imports).where(eq8(external_imports.file_id, file_id)).all()
+);
+var by_external_dependency = safe_query(
+  "external_imports.by_external_dependency",
+  (ctx, external_dependency_id) => ctx.db.select().from(external_imports).where(eq8(external_imports.external_dependency_id, external_dependency_id)).all()
+);
+var by_symbol = safe_query(
+  "external_imports.by_symbol",
+  (ctx, symbol_id) => ctx.db.query.symbol_external_links.findMany({
+    where: eq8(symbol_external_links.symbol_id, symbol_id),
+    with: {
+      external_import: {
+        with: {
+          external_dependency: true
+        }
+      }
+    }
+  })
+);
+
+// src/db/symbol_internal_links.ts
+var symbol_internal_links_exports = {};
+__export(symbol_internal_links_exports, {
+  by_from_symbol: () => by_from_symbol,
+  del_by_from_symbol: () => del_by_from_symbol,
+  exists: () => exists,
+  insert: () => insert4
+});
+import { and as and6, eq as eq9 } from "drizzle-orm";
+var by_from_symbol = safe_query(
+  "symbol_internal_links.by_from_symbol",
+  (ctx, from_symbol_id) => ctx.db.query.symbol_internal_links.findMany({
+    where: eq9(symbol_internal_links.from_symbol_id, from_symbol_id),
+    with: {
+      to_symbol: {
+        with: {
+          file: true
+        }
+      }
+    }
+  })
+);
+var insert4 = safe_query(
+  "symbol_internal_links.insert",
+  (ctx, value) => ctx.db.insert(symbol_internal_links).values(value).run()
+);
+var exists = safe_query(
+  "symbol_internal_links.exists",
+  (ctx, params) => ctx.db.select({ id: symbol_internal_links.id }).from(symbol_internal_links).where(and6(eq9(symbol_internal_links.from_symbol_id, params.from_symbol_id), eq9(symbol_internal_links.to_symbol_id, params.to_symbol_id))).get()
+);
+var del_by_from_symbol = safe_query(
+  "symbol_internal_links.del_by_from_symbol",
+  (ctx, from_symbol_id) => ctx.db.delete(symbol_internal_links).where(eq9(symbol_internal_links.from_symbol_id, from_symbol_id)).run()
+);
+
+// src/db/symbol_external_links.ts
+var symbol_external_links_exports = {};
+__export(symbol_external_links_exports, {
+  by_external_import: () => by_external_import,
+  by_symbol: () => by_symbol2,
+  del_by_symbol: () => del_by_symbol,
+  exists: () => exists2,
+  insert: () => insert5
+});
+import { and as and7, eq as eq10 } from "drizzle-orm";
+var by_symbol2 = safe_query(
+  "symbol_external_links.by_symbol",
+  (ctx, symbol_id) => ctx.db.select().from(symbol_external_links).where(eq10(symbol_external_links.symbol_id, symbol_id)).all()
+);
+var insert5 = safe_query(
+  "symbol_external_links.insert",
+  (ctx, value) => ctx.db.insert(symbol_external_links).values(value).run()
+);
+var by_external_import = safe_query(
+  "symbol_external_links.by_external_import",
+  (ctx, external_import_id) => ctx.db.select().from(symbol_external_links).where(eq10(symbol_external_links.external_import_id, external_import_id)).all()
+);
+var exists2 = safe_query(
+  "symbol_external_links.exists",
+  (ctx, params) => ctx.db.select({ id: symbol_external_links.id }).from(symbol_external_links).where(and7(eq10(symbol_external_links.symbol_id, params.symbol_id), eq10(symbol_external_links.external_import_id, params.external_import_id))).get()
+);
+var del_by_symbol = safe_query(
+  "symbol_external_links.del_by_symbol",
+  (ctx, symbol_id) => ctx.db.delete(symbol_external_links).where(eq10(symbol_external_links.symbol_id, symbol_id)).run()
+);
+
+// src/internals/context.ts
+async function create_context(sqlite, db6, config) {
+  const project_path = path.resolve(config.project_path);
+  const currentDir = dirname(fileURLToPath(import.meta.url));
+  const migrations_path = currentDir.includes("/dist") ? join2(currentDir, "../migrations") : join2(currentDir, "../../migrations");
+  const tsconfig_path = join2(project_path, "tsconfig.json");
+  if (!ts.sys.fileExists(tsconfig_path)) {
+    throw err.new("file_not_found", { path: tsconfig_path });
+  }
+  const tsconfig = ts.parseJsonConfigFileContent(ts.readConfigFile(tsconfig_path, ts.sys.readFile).config, ts.sys, project_path);
+  const program = ts.createProgram({ rootNames: tsconfig.fileNames, options: tsconfig.options });
+  const package_json_path = config.package_json_path ?? path.join(project_path, "package.json");
+  const node_modules_paths = config.node_modules_paths ?? [path.join(project_path, "node_modules")];
+  const dependencies2 = await get_dependencies(package_json_path, node_modules_paths);
+  const ctx = { db: db6, sqlite, migrations_path, project_path, program, dependencies: dependencies2 };
+  await migrate(ctx);
+  err.or_throw(
+    configs_exports.upsert(ctx, {
+      project_path,
+      description: config.description ?? null,
+      package_json_path: config.package_json_path ?? null,
+      node_modules_paths: config.node_modules_paths ? JSON.stringify(config.node_modules_paths) : null
+    })
+  );
+  return ctx;
+}
+async function context_from_config(config) {
+  const sqlite = new Database(config.db_path);
+  sqlite.pragma("foreign_keys = ON");
+  const db6 = drizzle(sqlite, { schema: schema_exports });
+  return create_context(sqlite, db6, config);
+}
+async function context_from_db(db_path) {
+  const sqlite = new Database(db_path);
+  sqlite.pragma("foreign_keys = ON");
+  const db6 = drizzle(sqlite, { schema: schema_exports });
+  const temp_ctx = { db: db6, sqlite };
+  const stored = err.or_throw(configs_exports.get(temp_ctx));
+  if (!stored) {
+    sqlite.close();
+    throw err.new("config_not_found", { db_path });
+  }
+  let node_modules_paths;
+  if (stored.node_modules_paths) {
+    try {
+      node_modules_paths = JSON.parse(stored.node_modules_paths);
+    } catch (parse_error) {
+      sqlite.close();
+      throw err.new("config_invalid_node_modules_paths", { db_path, reason: parse_error });
+    }
+  }
+  return create_context(sqlite, db6, {
+    db_path,
+    project_path: stored.project_path,
+    description: stored.description ?? void 0,
+    package_json_path: stored.package_json_path ?? void 0,
+    node_modules_paths
+  });
+}
+async function get_dependencies(package_json_path, node_modules_paths) {
+  const dependencies2 = {};
+  const package_json = JSON.parse(await readFile2(package_json_path, "utf-8"));
+  const packages = { ...package_json.dependencies ?? {}, ...package_json.devDependencies ?? {} };
+  for (const [name, version] of Object.entries(packages)) {
+    dependencies2[name] = { name, version, github_repo: await get_github_repo(node_modules_paths, name) };
+  }
+  return dependencies2;
+}
+async function get_github_repo(node_modules_paths, package_name) {
+  for (const node_modules_path of node_modules_paths) {
+    try {
+      const package_json_path = path.join(node_modules_path, package_name, "package.json");
+      const package_json = JSON.parse(await readFile2(package_json_path, "utf-8"));
+      const url = package_json.repository?.url || package_json.repository;
+      if (typeof url === "string") {
+        let repo = url.split("/").slice(-2).join("/");
+        if (repo.endsWith(".git")) repo = repo.slice(0, -4);
+        return repo.split(":").pop();
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+
+// src/cli/env.ts
+var env = {
+  read_file,
+  file_exists: (path6) => existsSync(path6),
+  argv: () => process.argv,
+  log: (...args) => console.log(...args),
+  error: (...args) => console.error(...args),
+  exit: (code) => process.exit(code)
+};
+
+// src/cli/index.ts
+import { Command as Command30 } from "commander";
+
+// src/cli/commands/update.ts
+import { Command } from "commander";
+
+// src/cli/commands/_common.ts
+import "zod";
+
+// src/cli/schema.ts
+import { z } from "zod";
+var Config = z.object({
+  db_path: z.string().describe("Path to SQLite database"),
+  project_path: z.string().describe("Path to TypeScript project"),
+  description: z.string().optional(),
+  package_json_path: z.string().optional(),
+  node_modules_paths: z.array(z.string()).optional()
+});
+var StringFilter = z.union([
+  z.string(),
+  z.object({ contains: z.string() }),
+  z.object({ starts_with: z.string() }),
+  z.object({ ends_with: z.string() })
+]);
+var OrderDirection = z.enum(["asc", "desc"]);
+var FileField = z.enum(["id", "directory_id", "path", "description", "state", "error"]);
+var FileState = z.enum(["to_scan", "to_describe", "ready"]);
+var FileSearchOptions = z.object({
+  select: z.array(FileField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  where: z.object({
+    id: z.number().optional(),
+    directory_id: z.number().optional(),
+    path: StringFilter.optional(),
+    description: StringFilter.optional(),
+    state: z.union([FileState, z.object({ contains: z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: z.tuple([FileField, OrderDirection]).optional()
+});
+var FileRelationOptions = z.object({
+  select: z.array(FileField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  deep: z.boolean().optional()
+});
+var SymbolField = z.enum(["id", "file_id", "type", "name", "text", "meta", "description", "is_exported", "state", "error"]);
+var SymbolType = z.enum(["function", "class", "class_method", "class_property", "variable", "type"]);
+var SymbolState = z.enum(["to_link", "to_describe", "ready"]);
+var SymbolSearchOptions = z.object({
+  select: z.array(SymbolField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  where: z.object({
+    id: z.number().optional(),
+    file_id: z.number().optional(),
+    type: z.union([SymbolType, z.object({ contains: z.string() })]).optional(),
+    name: StringFilter.optional(),
+    text: StringFilter.optional(),
+    meta: StringFilter.optional(),
+    description: StringFilter.optional(),
+    is_exported: z.boolean().optional(),
+    state: z.union([SymbolState, z.object({ contains: z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: z.tuple([SymbolField, OrderDirection]).optional()
+});
+var SymbolRelationOptions = z.object({
+  select: z.array(SymbolField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  deep: z.boolean().optional()
+});
+var DirectoryField = z.enum(["id", "parent_id", "path", "description", "state", "error"]);
+var DirectoryState = z.enum(["to_describe", "ready"]);
+var DirectorySearchOptions = z.object({
+  select: z.array(DirectoryField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  where: z.object({
+    id: z.number().optional(),
+    parent_id: z.number().optional(),
+    path: StringFilter.optional(),
+    description: StringFilter.optional(),
+    state: z.union([DirectoryState, z.object({ contains: z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: z.tuple([DirectoryField, OrderDirection]).optional()
+});
+var DirectoryRelationOptions = z.object({
+  select: z.array(DirectoryField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  deep: z.boolean().optional()
+});
+var DependencyField = z.enum(["id", "package", "subpath", "name", "version", "github_repo", "is_builtin", "description", "state", "error"]);
+var DependencyState = z.enum(["to_describe", "ready"]);
+var DependencySearchOptions = z.object({
+  select: z.array(DependencyField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional(),
+  where: z.object({
+    id: z.number().optional(),
+    package: StringFilter.optional(),
+    subpath: StringFilter.optional(),
+    name: StringFilter.optional(),
+    version: StringFilter.optional(),
+    github_repo: StringFilter.optional(),
+    is_builtin: z.boolean().optional(),
+    description: StringFilter.optional(),
+    state: z.union([DependencyState, z.object({ contains: z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: z.tuple([DependencyField, OrderDirection]).optional()
+});
+var DependencySelectOptions = z.object({
+  select: z.array(DependencyField).optional(),
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().nonnegative().optional()
+});
+
+// src/update/track_changes.ts
+import path2 from "path";
+import "typescript";
+import { stat } from "fs/promises";
+
+// src/update/events.ts
+function file_updated(ctx, file_id) {
+  const impacted_files_ids = err.or_throw(
+    expand({
+      items: [file_id],
+      get_key: (id) => id,
+      get_children: (id) => {
+        const imports2 = imports_exports.by_exporter_file(ctx, id);
+        if (err.any(imports2)) return imports2;
+        return imports2.map((x) => x.importer_file_id);
+      }
+    })
+  );
+  const dir_ids = err.or_throw(files_exports.get_directory_ids(ctx, impacted_files_ids));
+  const impacted_dirs_ids = err.or_throw(
+    expand({
+      items: dir_ids,
+      get_key: (id) => id,
+      get_children: (id) => {
+        const dir = directories_exports.by_id(ctx, id);
+        if (err.any(dir)) return dir;
+        return dir?.parent_id ? [dir.parent_id] : [];
+      }
+    })
+  );
+  err.or_throw(files_exports.update_many(ctx, impacted_files_ids, { state: "to_scan" }));
+  err.or_throw(directories_exports.update_many(ctx, impacted_dirs_ids, { state: "to_describe" }));
+}
+
+// src/update/track_changes.ts
+async function track_changes(ctx) {
+  const db_files = err.or_throw(files_exports.all(ctx));
+  const { created, updated, deleted } = await changes(ctx, get_source_files(ctx), db_files);
+  for (const { source_file, hash } of created) handle_new_source_file(ctx, source_file, hash);
+  for (const { db_file, hash } of updated) handle_changed_source_file(ctx, db_file, hash);
+  for (const { db_file } of deleted) handle_deleted_source_file(ctx, db_file);
+}
+function get_source_files(ctx) {
+  const src_files = [];
+  for (const file of ctx.program.getSourceFiles()) {
+    if (ctx.program.isSourceFileDefaultLibrary(file)) continue;
+    if (ctx.program.isSourceFileFromExternalLibrary(file)) continue;
+    if (!path2.resolve(file.fileName).startsWith(ctx.project_path)) continue;
+    src_files.push(file);
+  }
+  return src_files;
+}
+function handle_new_source_file(ctx, file, hash) {
+  const file_path = err.or_throw(get_file_path(ctx, file));
+  const dirs_paths = err.or_throw(get_parents_paths(ctx, file));
+  let parent_dir_id = null;
+  for (const dir_path of dirs_paths) {
+    let dir = err.or_throw(directories_exports.by_path(ctx, dir_path));
+    if (dir) {
+      err.or_throw(directories_exports.update(ctx, dir.id, { state: "to_describe" }));
+    } else {
+      dir = err.or_throw(directories_exports.insert(ctx, { path: dir_path, state: "to_describe", parent_id: parent_dir_id }));
+    }
+    parent_dir_id = dir.id;
+  }
+  err.or_throw(files_exports.insert(ctx, { directory_id: parent_dir_id, path: file_path, state: "to_scan", hash }));
+}
+function handle_changed_source_file(ctx, db_file, hash) {
+  file_updated(ctx, db_file.id);
+  err.or_throw(files_exports.update(ctx, db_file.id, { hash }));
+}
+function handle_deleted_source_file(ctx, db_file) {
+  err.or_throw(handle_changed_source_file(ctx, db_file, ""));
+  err.or_throw(files_exports.del(ctx, db_file.id));
+}
+async function changes(ctx, source_files, db_files) {
+  const created = [];
+  const updated = [];
+  const deleted = [];
+  const db_files_index = group_by_unique(db_files, (x) => x.path);
+  const source_files_index = group_by_unique(source_files, (x) => err.or(get_file_path(ctx, x), ""));
+  const filenames = new Set(Object.keys(source_files_index).concat(Object.keys(db_files_index)));
+  for (const filename of filenames) {
+    const db_file = db_files_index[filename];
+    const source_file = source_files_index[filename];
+    if (!db_file && source_file) created.push({ source_file, hash: await file_signature(source_file.fileName) });
+    if (db_file && !source_file) deleted.push({ db_file });
+    if (db_file && source_file) {
+      const hash = await file_signature(source_file.fileName);
+      if (db_file.hash !== hash) updated.push({ db_file, source_file, hash });
+    }
+  }
+  return { created, updated, deleted };
+}
+function get_file_path(ctx, file) {
+  const absolute_path = path2.resolve(file.fileName);
+  if (absolute_path.startsWith(ctx.project_path)) return absolute_path.slice(ctx.project_path.length);
+  return err.new("file_outside_project_path", { file_path: absolute_path, project_path: ctx.project_path });
+}
+function get_parents_paths(ctx, file) {
+  const file_path = get_file_path(ctx, file);
+  if (err.any(file_path)) return file_path;
+  const dirs = [];
+  let current = path2.dirname(file_path);
+  while (current !== path2.sep) {
+    dirs.push(current);
+    current = path2.dirname(current);
+  }
+  dirs.push(current);
+  return dirs.reverse();
+}
+async function file_signature(file_path) {
+  const stats = await stat(file_path);
+  return `${stats.mtimeMs}:${stats.size}`;
+}
+
+// src/update/sync_external_dependencies.ts
+async function sync_external_dependencies(ctx) {
+  const db_deps = err.or_throw(external_dependencies_exports.all(ctx));
+  for (const ctx_dep of Object.values(ctx.dependencies)) {
+    const existing = db_deps.filter((d) => d.package === ctx_dep.name);
+    if (existing.length === 0) continue;
+    const needs_update = existing.some((d) => d.version !== ctx_dep.version || (d.github_repo || "") !== (ctx_dep.github_repo || ""));
+    if (!needs_update) continue;
+    for (const db_dep of existing) {
+      err.or_throw(
+        external_dependencies_exports.update(ctx, db_dep.id, {
+          version: ctx_dep.version,
+          github_repo: ctx_dep.github_repo,
+          state: "to_describe",
+          error: null
+        })
+      );
+      const files5 = err.or_throw(files_exports.using_dependency(ctx, db_dep.id, ["id"]));
+      for (const file of files5) file_updated(ctx, file.id);
+    }
+  }
+}
+
+// src/update/scan_files/scan_files.ts
+import path4 from "path";
+import ts10 from "typescript";
+
+// src/update/scan_files/imports.ts
+import ts4 from "typescript";
+
+// src/update/scan_files/common.ts
+import path3 from "path";
+import ts3 from "typescript";
+function is_external_module(ctx, source_file, module_path) {
+  const resolved = ts3.resolveModuleName(module_path, source_file.fileName, ctx.program.getCompilerOptions(), ts3.sys);
+  if (!resolved.resolvedModule) return true;
+  const resolved_path = path3.resolve(resolved.resolvedModule.resolvedFileName);
+  return !resolved_path.startsWith(ctx.project_path);
+}
+function has_export_modifier(node) {
+  if (!ts3.canHaveModifiers(node)) return false;
+  const modifiers = ts3.getModifiers(node);
+  if (!modifiers) return false;
+  return modifiers.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword);
+}
+function has_default_modifier(node) {
+  if (!ts3.canHaveModifiers(node)) return false;
+  const modifiers = ts3.getModifiers(node);
+  if (!modifiers) return false;
+  return modifiers.some((m) => m.kind === ts3.SyntaxKind.DefaultKeyword);
+}
+function extract_parameters(node, source_file) {
+  return node.parameters.map((param) => ({
+    name: ts3.isIdentifier(param.name) ? param.name.text : param.name.getText(source_file),
+    type: param.type ? param.type.getText(source_file) : null,
+    optional: !!param.questionToken,
+    rest: !!param.dotDotDotToken,
+    default: param.initializer ? param.initializer.getText(source_file) : null
+  }));
+}
+function extract_type_parameters(node, source_file) {
+  if (!("typeParameters" in node) || !node.typeParameters) return [];
+  return node.typeParameters.map((tp) => tp.getText(source_file));
+}
+function extract_jsdoc_comment(node, source_file) {
+  const sf = source_file || node.getSourceFile();
+  if (!sf) return null;
+  const sourceText = sf.getFullText();
+  const ranges = ts3.getLeadingCommentRanges(sourceText, node.getFullStart());
+  if (!ranges || ranges.length === 0) return null;
+  const lastComment = ranges[ranges.length - 1];
+  if (!lastComment) return null;
+  const commentText = sourceText.slice(lastComment.pos, lastComment.end);
+  if (commentText.startsWith("/**")) {
+    return commentText;
+  }
+  return null;
+}
+function extract_decorators(node, source_file) {
+  if (!ts3.canHaveDecorators(node)) return [];
+  const decorators = ts3.getDecorators(node);
+  if (!decorators) return [];
+  const sf = source_file || node.getSourceFile();
+  return decorators.map((decorator) => {
+    const expr = decorator.expression;
+    if (ts3.isIdentifier(expr)) {
+      return { name: expr.text };
+    }
+    if (ts3.isCallExpression(expr) && ts3.isIdentifier(expr.expression)) {
+      return {
+        name: expr.expression.text,
+        arguments: expr.arguments.map((arg) => arg.getText(sf))
+      };
+    }
+    return { name: decorator.expression.getText(sf) };
+  });
+}
+function is_builtin_module(package_name) {
+  const builtins = [
+    "fs",
+    "path",
+    "http",
+    "https",
+    "url",
+    "crypto",
+    "os",
+    "util",
+    "stream",
+    "events",
+    "buffer",
+    "child_process",
+    "cluster",
+    "dns",
+    "net",
+    "tls",
+    "dgram",
+    "readline",
+    "repl",
+    "vm",
+    "zlib",
+    "assert",
+    "querystring",
+    "string_decoder",
+    "timers",
+    "tty",
+    "v8",
+    "worker_threads"
+  ];
+  return builtins.includes(package_name) || package_name.startsWith("node:");
+}
+function is_dynamic_import(node) {
+  if (!ts3.isCallExpression(node)) return false;
+  if (node.expression.kind !== ts3.SyntaxKind.ImportKeyword) return false;
+  if (node.arguments.length !== 1) return false;
+  const arg = node.arguments[0];
+  if (!arg) return false;
+  return ts3.isStringLiteral(arg);
+}
+
+// src/update/scan_files/imports.ts
+function is_import(ctx, source_file, node) {
+  if (!ts4.isImportDeclaration(node) || !node.moduleSpecifier || !ts4.isStringLiteral(node.moduleSpecifier)) return false;
+  return !is_external_module(ctx, source_file, node.moduleSpecifier.text);
+}
+function extract_import(ctx, source_file, node, file_id) {
+  const imports2 = [];
+  const clause = node.importClause;
+  if (!clause || !node.moduleSpecifier || !ts4.isStringLiteral(node.moduleSpecifier)) return imports2;
+  const exporter_file_id = resolve_exporter_file(ctx, source_file, node.moduleSpecifier.text);
+  if (err.any(exporter_file_id)) return imports2;
+  if (clause.name) {
+    imports2.push({
+      importer_file_id: file_id,
+      exporter_file_id,
+      name: "default",
+      alias: clause.name.text,
+      state: "to_link"
+    });
+  }
+  if (clause.namedBindings && ts4.isNamedImports(clause.namedBindings)) {
+    for (const element of clause.namedBindings.elements) {
+      imports2.push({
+        importer_file_id: file_id,
+        exporter_file_id,
+        name: (element.propertyName || element.name).text,
+        alias: element.name.text,
+        state: "to_link"
+      });
+    }
+  }
+  if (clause.namedBindings && ts4.isNamespaceImport(clause.namedBindings)) {
+    imports2.push({
+      importer_file_id: file_id,
+      exporter_file_id,
+      name: "*",
+      alias: clause.namedBindings.name.text,
+      state: "to_link"
+    });
+  }
+  return imports2;
+}
+function extract_dynamic_import(ctx, source_file, node, file_id) {
+  const arg = node.arguments[0];
+  const module_specifier = arg.text;
+  const exporter_file_id = resolve_exporter_file(ctx, source_file, module_specifier);
+  if (err.any(exporter_file_id)) return null;
+  return {
+    importer_file_id: file_id,
+    exporter_file_id,
+    name: "*",
+    alias: "__dynamic_import__",
+    state: "to_link",
+    is_dynamic: true
+  };
+}
+function resolve_exporter_file(ctx, source_file, module_specifier) {
+  const resolution = ts4.resolveModuleName(module_specifier, source_file.fileName, ctx.program.getCompilerOptions(), ts4.sys);
+  if (!resolution.resolvedModule) {
+    return err.new("module_resolution_failed", { module: module_specifier, from: source_file.fileName });
+  }
+  const resolved_path = resolution.resolvedModule.resolvedFileName;
+  const file_path = resolved_path.startsWith(ctx.project_path) ? resolved_path.slice(ctx.project_path.length) : resolved_path;
+  const file = files_exports.by_path(ctx, file_path);
+  if (err.any(file)) return file;
+  if (!file) {
+    return err.new("exporter_file_not_found", { path: file_path, module: module_specifier });
+  }
+  return file.id;
+}
+
+// src/update/scan_files/external_imports.ts
+import ts5 from "typescript";
+function is_external_import(ctx, source_file, node) {
+  if (!ts5.isImportDeclaration(node) || !node.moduleSpecifier || !ts5.isStringLiteral(node.moduleSpecifier)) return false;
+  return is_external_module(ctx, source_file, node.moduleSpecifier.text);
+}
+function parse_module_specifier(spec) {
+  let is_builtin = false;
+  let normalized = spec;
+  if (spec.startsWith("node:")) {
+    normalized = spec.slice(5);
+    is_builtin = true;
+  } else {
+    is_builtin = is_builtin_module(spec);
+  }
+  if (normalized.startsWith("@")) {
+    const parts = normalized.split("/");
+    if (parts.length <= 2) {
+      return { pkg: normalized, subpath: null, is_builtin };
+    }
+    const pkg = `${parts[0]}/${parts[1]}`;
+    const subpath = "/" + parts.slice(2).join("/");
+    return { pkg, subpath, is_builtin };
+  } else {
+    const slash_idx = normalized.indexOf("/");
+    if (slash_idx === -1) {
+      return { pkg: normalized, subpath: null, is_builtin };
+    }
+    const pkg = normalized.slice(0, slash_idx);
+    const subpath = normalized.slice(slash_idx);
+    return { pkg, subpath, is_builtin };
+  }
+}
+function extract_external_import_info(node) {
+  const results = [];
+  const module_specifier = node.moduleSpecifier.text;
+  const { pkg, subpath, is_builtin } = parse_module_specifier(module_specifier);
+  const clause = node.importClause;
+  if (!clause) {
+    results.push({
+      package: pkg,
+      subpath,
+      name: null,
+      alias: "__side_effect__",
+      is_builtin
+    });
+    return results;
+  }
+  if (clause.name) {
+    results.push({
+      package: pkg,
+      subpath,
+      name: "default",
+      alias: clause.name.text,
+      is_builtin
+    });
+  }
+  if (clause.namedBindings && ts5.isNamedImports(clause.namedBindings)) {
+    for (const element of clause.namedBindings.elements) {
+      results.push({
+        package: pkg,
+        subpath,
+        name: (element.propertyName || element.name).text,
+        alias: element.name.text,
+        is_builtin
+      });
+    }
+  }
+  if (clause.namedBindings && ts5.isNamespaceImport(clause.namedBindings)) {
+    results.push({
+      package: pkg,
+      subpath,
+      name: "*",
+      alias: clause.namedBindings.name.text,
+      is_builtin
+    });
+  }
+  return results;
+}
+function extract_external_import(ctx, node, file_id) {
+  const infos = extract_external_import_info(node);
+  const external_imports2 = [];
+  for (const info of infos) {
+    const dep_meta = Object.values(ctx.dependencies).find((dep) => info.package.startsWith(dep.name));
+    const dependency = external_dependencies_exports.get_or_create(ctx, {
+      package: info.package,
+      subpath: info.subpath,
+      name: info.name,
+      version: dep_meta?.version,
+      github_repo: dep_meta?.github_repo,
+      is_builtin: info.is_builtin,
+      state: "to_describe"
+    });
+    if (err.any(dependency)) return dependency;
+    external_imports2.push({ file_id, external_dependency_id: dependency.id, alias: info.alias, is_dynamic: false });
+  }
+  return external_imports2;
+}
+function extract_external_dynamic_import(ctx, node, file_id) {
+  const arg = node.arguments[0];
+  const module_specifier = arg.text;
+  const { pkg, subpath, is_builtin } = parse_module_specifier(module_specifier);
+  const dep_meta = Object.values(ctx.dependencies).find((dep) => pkg.startsWith(dep.name));
+  const dependency = external_dependencies_exports.get_or_create(ctx, {
+    package: pkg,
+    subpath,
+    name: "*",
+    version: dep_meta?.version,
+    github_repo: dep_meta?.github_repo,
+    is_builtin,
+    state: "to_describe"
+  });
+  if (err.any(dependency)) return dependency;
+  return { file_id, external_dependency_id: dependency.id, alias: "__dynamic_import__", is_dynamic: true };
+}
+
+// src/update/scan_files/types.ts
+import ts6 from "typescript";
+function is_type(node) {
+  return ts6.isTypeAliasDeclaration(node) || ts6.isInterfaceDeclaration(node) || ts6.isEnumDeclaration(node);
+}
+function extract_type_symbol(node, file_id, source_file) {
+  const meta2 = ts6.isEnumDeclaration(node) ? extract_enum_meta(node, source_file) : ts6.isInterfaceDeclaration(node) ? extract_interface_meta(node, source_file) : extract_type_alias_meta(node, source_file);
+  return {
+    file_id,
+    type: "type",
+    name: node.name.text,
+    text: node.getText(source_file),
+    meta: JSON.stringify(meta2),
+    is_exported: has_export_modifier(node),
+    state: "to_link"
+  };
+}
+function extract_enum_meta(node, source_file) {
+  const enum_values = {};
+  for (const member of node.members) {
+    if (ts6.isIdentifier(member.name) || ts6.isStringLiteral(member.name)) {
+      const name = member.name.text;
+      const value = member.initializer ? member.initializer.getText(source_file) : "auto";
+      enum_values[name] = value;
+    }
+  }
+  return {
+    kind: "enum",
+    type_parameters: [],
+    extends: [],
+    members: [],
+    enum_values,
+    decorators: extract_decorators(node, source_file),
+    comment: extract_jsdoc_comment(node, source_file)
+  };
+}
+function extract_interface_meta(node, source_file) {
+  const members = [];
+  for (const member of node.members) {
+    if (ts6.isPropertySignature(member) && ts6.isIdentifier(member.name)) {
+      members.push({
+        name: member.name.text,
+        type: member.type ? member.type.getText(source_file) : "any",
+        optional: !!member.questionToken
+      });
+    } else if (ts6.isMethodSignature(member) && ts6.isIdentifier(member.name)) {
+      const params = member.parameters.map((p) => {
+        const param_type = p.type ? p.type.getText(source_file) : "any";
+        return `${p.name.getText(source_file)}: ${param_type}`;
+      }).join(", ");
+      const return_type = member.type ? member.type.getText(source_file) : "void";
+      members.push({
+        name: member.name.text,
+        type: `(${params}) => ${return_type}`,
+        optional: !!member.questionToken
+      });
+    }
+  }
+  const extends_clauses = node.heritageClauses?.filter((c) => c.token === ts6.SyntaxKind.ExtendsKeyword).flatMap((c) => c.types.map((t) => t.expression.getText(source_file))) || [];
+  return {
+    kind: "interface",
+    type_parameters: extract_type_parameters(node, source_file),
+    extends: extends_clauses,
+    members,
+    enum_values: {},
+    decorators: extract_decorators(node, source_file),
+    comment: extract_jsdoc_comment(node, source_file)
+  };
+}
+function extract_type_alias_meta(node, source_file) {
+  return {
+    kind: "type_alias",
+    type_parameters: extract_type_parameters(node, source_file),
+    extends: [],
+    members: [],
+    enum_values: {},
+    decorators: extract_decorators(node, source_file),
+    comment: extract_jsdoc_comment(node, source_file)
+  };
+}
+
+// src/update/scan_files/functions.ts
+import ts7 from "typescript";
+function is_function(node) {
+  if (!ts7.isFunctionDeclaration(node)) return false;
+  return !!node.name || has_default_modifier(node);
+}
+function extract_function_symbol(node, file_id, source_file) {
+  const is_default = has_default_modifier(node);
+  const name = is_default ? "default" : node.name?.text || "default";
+  const meta2 = {
+    kind: "function_declaration",
+    parameters: extract_parameters(node, source_file),
+    return_type: node.type ? node.type.getText(source_file) : null,
+    type_parameters: extract_type_parameters(node, source_file),
+    modifiers: {
+      async: !!node.modifiers?.some((m) => m.kind === ts7.SyntaxKind.AsyncKeyword),
+      generator: !!node.asteriskToken
+    },
+    decorators: extract_decorators(node, source_file),
+    comment: extract_jsdoc_comment(node, source_file)
+  };
+  return {
+    file_id,
+    type: "function",
+    name,
+    text: node.getText(source_file),
+    meta: JSON.stringify(meta2),
+    is_exported: has_export_modifier(node),
+    state: "to_link"
+  };
+}
+
+// src/update/scan_files/variables.ts
+import ts8 from "typescript";
+function is_function_declaration(declaration) {
+  return !!(declaration.initializer && (ts8.isArrowFunction(declaration.initializer) || ts8.isFunctionExpression(declaration.initializer)));
+}
+function extract_variable_symbol(node, file_id, source_file) {
+  const symbols4 = [];
+  const is_exported = has_export_modifier(node);
+  const declaration_kind = node.declarationList.flags & ts8.NodeFlags.Const ? "const" : node.declarationList.flags & ts8.NodeFlags.Let ? "let" : "var";
+  for (const declaration of node.declarationList.declarations) {
+    if (!ts8.isIdentifier(declaration.name)) continue;
+    if (is_function_declaration(declaration)) {
+      const func_node = declaration.initializer;
+      const meta2 = {
+        kind: ts8.isArrowFunction(func_node) ? "arrow_function" : "function_expression",
+        parameters: extract_parameters(func_node, source_file),
+        return_type: func_node.type ? func_node.type.getText(source_file) : null,
+        type_parameters: extract_type_parameters(func_node, source_file),
+        modifiers: {
+          async: !!func_node.modifiers?.some((m) => m.kind === ts8.SyntaxKind.AsyncKeyword),
+          generator: ts8.isFunctionExpression(func_node) && !!func_node.asteriskToken
+        },
+        decorators: extract_decorators(node, source_file),
+        comment: extract_jsdoc_comment(node, source_file)
+      };
+      symbols4.push({
+        file_id,
+        type: "function",
+        name: declaration.name.text,
+        text: node.getText(source_file),
+        meta: JSON.stringify(meta2),
+        is_exported,
+        state: "to_link"
+      });
+    } else {
+      const meta2 = {
+        declaration_kind,
+        type: declaration.type ? declaration.type.getText(source_file) : null,
+        value: declaration.initializer ? declaration.initializer.getText(source_file) : null,
+        decorators: extract_decorators(node, source_file),
+        comment: extract_jsdoc_comment(node, source_file)
+      };
+      symbols4.push({
+        file_id,
+        type: "variable",
+        name: declaration.name.text,
+        text: node.getText(source_file),
+        meta: JSON.stringify(meta2),
+        is_exported,
+        state: "to_link"
+      });
+    }
+  }
+  return symbols4;
+}
+
+// src/update/scan_files/classes.ts
+import ts9 from "typescript";
+function is_class(node) {
+  if (!ts9.isClassDeclaration(node)) return false;
+  return !!node.name || has_default_modifier(node);
+}
+function extract_class_symbol(node, file_id, source_file) {
+  const is_default = has_default_modifier(node);
+  const name = is_default ? "default" : node.name?.text || "default";
+  const meta2 = {
+    extends: node.heritageClauses?.find((c) => c.token === ts9.SyntaxKind.ExtendsKeyword)?.types[0]?.expression.getText(source_file) || null,
+    implements: node.heritageClauses?.find((c) => c.token === ts9.SyntaxKind.ImplementsKeyword)?.types.map((t) => t.expression.getText(source_file)) || [],
+    type_parameters: extract_type_parameters(node, source_file),
+    modifiers: {
+      abstract: !!node.modifiers?.some((m) => m.kind === ts9.SyntaxKind.AbstractKeyword)
+    },
+    decorators: extract_decorators(node, source_file),
+    comment: extract_jsdoc_comment(node, source_file)
+  };
+  return {
+    file_id,
+    type: "class",
+    name,
+    text: node.getText(source_file),
+    meta: JSON.stringify(meta2),
+    is_exported: has_export_modifier(node),
+    state: "to_link"
+  };
+}
+function get_visibility(member) {
+  if (!ts9.canHaveModifiers(member)) return null;
+  const modifiers = ts9.getModifiers(member);
+  if (!modifiers) return null;
+  if (modifiers.some((m) => m.kind === ts9.SyntaxKind.PrivateKeyword)) return "private";
+  if (modifiers.some((m) => m.kind === ts9.SyntaxKind.ProtectedKeyword)) return "protected";
+  if (modifiers.some((m) => m.kind === ts9.SyntaxKind.PublicKeyword)) return "public";
+  return null;
+}
+function extract_class_fields(node, file_id, source_file) {
+  const symbols4 = [];
+  if (!node.name) return symbols4;
+  const class_name = node.name.text;
+  node.members.forEach((member) => {
+    if (ts9.isMethodDeclaration(member) && member.name && ts9.isIdentifier(member.name)) {
+      const meta2 = {
+        class_name,
+        visibility: get_visibility(member),
+        parameters: extract_parameters(member, source_file),
+        return_type: member.type ? member.type.getText(source_file) : null,
+        type_parameters: extract_type_parameters(member, source_file),
+        modifiers: {
+          static: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.StaticKeyword),
+          async: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.AsyncKeyword),
+          abstract: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.AbstractKeyword),
+          readonly: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword)
+        },
+        decorators: extract_decorators(member, source_file),
+        comment: extract_jsdoc_comment(member, source_file)
+      };
+      symbols4.push({
+        file_id,
+        type: "class_method",
+        name: `${class_name}.${member.name.text}`,
+        text: member.getText(source_file),
+        meta: JSON.stringify(meta2),
+        is_exported: false,
+        state: "to_link"
+      });
+    }
+    if (ts9.isPropertyDeclaration(member) && member.name && ts9.isIdentifier(member.name)) {
+      const meta2 = {
+        class_name,
+        visibility: get_visibility(member),
+        type: member.type ? member.type.getText(source_file) : null,
+        optional: !!member.questionToken,
+        modifiers: {
+          static: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.StaticKeyword),
+          readonly: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.ReadonlyKeyword),
+          abstract: !!member.modifiers?.some((m) => m.kind === ts9.SyntaxKind.AbstractKeyword)
+        },
+        decorators: extract_decorators(member, source_file),
+        comment: extract_jsdoc_comment(member, source_file)
+      };
+      symbols4.push({
+        file_id,
+        type: "class_property",
+        name: `${class_name}.${member.name.text}`,
+        text: member.getText(source_file),
+        meta: JSON.stringify(meta2),
+        is_exported: false,
+        state: "to_link"
+      });
+    }
+  });
+  return symbols4;
+}
+
+// src/update/scan_files/scan_files.ts
+async function scan_files(ctx) {
+  const files5 = err.or_throw(files_exports.by_state(ctx, "to_scan"));
+  for (const file of files5) {
+    const res = scan_file(ctx, file);
+    if (err.any(res)) {
+      err.or_throw(files_exports.update(ctx, file.id, { error: String(res) }));
+    } else {
+      err.or_throw(files_exports.update(ctx, file.id, { state: "to_describe", error: null }));
+    }
+  }
+}
+function scan_file(ctx, file) {
+  return err.pipe(
+    () => symbols_exports.del_by_file(ctx, file.id),
+    () => imports_exports.del_by_importer_file(ctx, file.id),
+    () => external_imports_exports.del_by_file(ctx, file.id),
+    () => get_source_file(ctx, file.path),
+    (source_file) => parse_file(ctx, source_file, file.id),
+    ({ imports: imports2, symbols: symbols4, external_imports: external_imports2 }) => err.pipe(
+      () => external_imports2.length && external_imports_exports.insert_many(ctx, external_imports2),
+      () => imports2.length && imports_exports.insert_many(ctx, imports2),
+      () => symbols4.length && symbols_exports.insert_many(ctx, symbols4)
+    )
+  );
+}
+function get_source_file(ctx, file_path) {
+  const source_file = ctx.program.getSourceFile(path4.join(ctx.project_path, file_path));
+  if (!source_file) return err.new("file_not_found", { path: file_path });
+  return source_file;
+}
+function parse_file(ctx, source_file, file_id) {
+  const imports2 = [];
+  const symbols4 = [];
+  const external_imports2 = [];
+  function find_dynamic_imports(node) {
+    if (is_dynamic_import(node)) {
+      const arg = node.arguments[0];
+      if (is_external_module(ctx, source_file, arg.text)) {
+        const result = extract_external_dynamic_import(ctx, node, file_id);
+        if (err.any(result)) return result;
+        external_imports2.push(result);
+      } else {
+        const result = extract_dynamic_import(ctx, source_file, node, file_id);
+        if (result) imports2.push(result);
+      }
+    }
+    ts10.forEachChild(node, find_dynamic_imports);
+  }
+  let error = void 0;
+  ts10.forEachChild(source_file, (statement) => {
+    if (error) return;
+    const res = parse_node(ctx, source_file, statement, file_id);
+    if (err.any(res)) {
+      error = res;
+      return;
+    }
+    imports2.push(...res.imports);
+    symbols4.push(...res.symbols);
+    external_imports2.push(...res.external_imports);
+    error = find_dynamic_imports(statement);
+  });
+  if (error) return error;
+  return { imports: imports2, symbols: symbols4, external_imports: external_imports2 };
+}
+function parse_node(ctx, source_file, node, file_id) {
+  const imports2 = [];
+  const symbols4 = [];
+  const external_imports2 = [];
+  if (is_external_import(ctx, source_file, node)) {
+    const result = extract_external_import(ctx, node, file_id);
+    if (err.any(result)) return result;
+    external_imports2.push(...result);
+  } else if (is_import(ctx, source_file, node)) {
+    imports2.push(...extract_import(ctx, source_file, node, file_id));
+  } else if (ts10.isExportAssignment(node) && !node.isExportEquals) {
+    symbols4.push({
+      file_id,
+      type: "variable",
+      name: "default",
+      text: node.getText(source_file),
+      meta: JSON.stringify({
+        declaration_kind: "const",
+        type: null,
+        value: node.expression.getText(source_file),
+        decorators: [],
+        comment: null
+      }),
+      is_exported: true,
+      state: "to_link"
+    });
+  } else if (ts10.isExportDeclaration(node) && node.exportClause && ts10.isNamedExports(node.exportClause) && !node.moduleSpecifier) {
+    for (const element of node.exportClause.elements) {
+      if (element.name.text === "default") {
+        const localName = element.propertyName?.text || element.name.text;
+        symbols4.push({
+          file_id,
+          type: "variable",
+          name: "default",
+          text: node.getText(source_file),
+          meta: JSON.stringify({ declaration_kind: "const", type: null, value: localName, is_reexport: true, decorators: [], comment: null }),
+          is_exported: true,
+          state: "to_link"
+        });
+      }
+    }
+  } else if (is_type(node)) {
+    symbols4.push(extract_type_symbol(node, file_id, source_file));
+  } else if (is_function(node)) {
+    symbols4.push(extract_function_symbol(node, file_id, source_file));
+  } else if (ts10.isVariableStatement(node)) {
+    symbols4.push(...extract_variable_symbol(node, file_id, source_file));
+  } else if (is_class(node)) {
+    symbols4.push(extract_class_symbol(node, file_id, source_file));
+    symbols4.push(...extract_class_fields(node, file_id, source_file));
+  }
+  return { imports: imports2, symbols: symbols4, external_imports: external_imports2 };
+}
+
+// src/update/link_imports.ts
+async function link_imports(ctx) {
+  const imports2 = err.or_throw(imports_exports.by_state(ctx, "to_link"));
+  let i = 0;
+  for (const import_ of imports2) {
+    const res = link_import(ctx, import_);
+    if (err.any(res)) err.or_throw(imports_exports.update(ctx, import_.id, { error: String(res) }));
+  }
+}
+function link_import(ctx, import_) {
+  if (import_.name === "*") {
+    return imports_exports.update(ctx, import_.id, { state: "ready", error: null });
+  }
+  const symbol = symbols_exports.by_file_and_name(ctx, { file_id: import_.exporter_file_id, name: import_.name, is_exported: true });
+  if (err.any(symbol)) return symbol;
+  if (!symbol) return err.new("exported_symbol_not_found", { name: import_.name, file_id: import_.exporter_file_id });
+  return imports_exports.update(ctx, import_.id, { symbol_id: symbol.id, state: "ready", error: null });
+}
+
+// src/update/link_symbols.ts
+import path5 from "path";
+import ts11 from "typescript";
+async function link_symbols(ctx) {
+  const symbols4 = err.or_throw(symbols_exports.by_state(ctx, "to_link"));
+  let i = 0;
+  for (const symbol of symbols4) {
+    const res = link_symbol(ctx, symbol);
+    if (err.any(res)) {
+      err.or_throw(symbols_exports.update(ctx, symbol.id, { error: String(res) }));
+    }
+  }
+}
+function link_symbol(ctx, symbol) {
+  if (!symbol.text) return err.new("symbol_missing_text", { symbol_id: symbol.id, name: symbol.name });
+  const resolutions = find_symbol_references(ctx, symbol);
+  if (err.any(resolutions)) return resolutions;
+  for (const resolution of resolutions) {
+    if (resolution.type === "internal") create_internal_link(ctx, symbol, resolution);
+    if (resolution.type === "external") create_external_link(ctx, symbol, resolution);
+  }
+  return symbols_exports.update(ctx, symbol.id, { state: "to_describe", error: null });
+}
+function find_symbol_references(ctx, symbol) {
+  const file = files_exports.by_id(ctx, symbol.file_id);
+  if (err.any(file)) return file;
+  if (!file) return err.new("file_not_found", { path: `file_id=${symbol.file_id}` });
+  const file_path = path5.join(ctx.project_path, file.path);
+  const source_file = ctx.program.getSourceFile(file_path);
+  if (!source_file) return err.new("file_not_found", { path: file_path });
+  const symbol_node = find_symbol_node(source_file, symbol);
+  if (!symbol_node) return err.new("symbol_node_not_found", { symbol_id: symbol.id, name: symbol.name, file_path: file.path });
+  const type_checker = ctx.program.getTypeChecker();
+  const resolutions = [];
+  const seen = /* @__PURE__ */ new Set();
+  function visit(node) {
+    const ts_symbol = type_checker.getSymbolAtLocation(node);
+    if (!ts11.isIdentifier(node) || is_declaration(node.parent, node) || !ts_symbol) {
+      ts11.forEachChild(node, visit);
+      return;
+    }
+    const resolution = resolve_ts_symbol(ctx, type_checker, ts_symbol, symbol);
+    if (resolution) {
+      const key = `${resolution.type}:${resolution.type === "internal" ? resolution.symbol_id : resolution.external_import_id}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        resolutions.push(resolution);
+      }
+    }
+    ts11.forEachChild(node, visit);
+  }
+  visit(symbol_node);
+  return resolutions;
+}
+function resolve_ts_symbol(ctx, type_checker, ts_symbol, from_symbol) {
+  let symbol_to_use = ts_symbol;
+  if (ts_symbol.flags & ts11.SymbolFlags.Alias) {
+    symbol_to_use = type_checker.getAliasedSymbol(ts_symbol) || symbol_to_use;
+  }
+  const declarations = symbol_to_use.getDeclarations();
+  if (!declarations || declarations.length === 0 || !declarations[0]) return null;
+  const declaration_source_file = declarations[0].getSourceFile();
+  if (declaration_source_file.fileName.includes("/lib.") && !declaration_source_file.fileName.includes("node_modules")) {
+    return null;
+  }
+  if (!declaration_source_file.fileName.startsWith(ctx.project_path) || declaration_source_file.fileName.includes("node_modules")) {
+    const external_import_links = external_imports_exports.by_file(ctx, from_symbol.file_id);
+    if (err.any(external_import_links)) return null;
+    for (const ext_import of external_import_links) {
+      const ext_dep = external_dependencies_exports.by_id(ctx, ext_import.external_dependency_id);
+      if (err.any(ext_dep) || !ext_dep) continue;
+      if (ext_import.alias === symbol_to_use.name || ext_dep.name === symbol_to_use.name) {
+        return { type: "external", external_import_id: ext_import.id };
+      }
+    }
+    return null;
+  }
+  let file_path = declaration_source_file.fileName;
+  if (file_path.startsWith(ctx.project_path)) {
+    file_path = file_path.substring(ctx.project_path.length);
+  }
+  const file = files_exports.by_path(ctx, file_path);
+  if (err.any(file) || !file) return null;
+  if (file.id === from_symbol.file_id) {
+    const file_symbols2 = symbols_exports.by_file(ctx, file.id);
+    if (err.any(file_symbols2)) return null;
+    for (const file_symbol of file_symbols2) {
+      if (file_symbol.name === symbol_to_use.name && file_symbol.id !== from_symbol.id) {
+        return { type: "internal", symbol_id: file_symbol.id, file_id: file.id };
+      }
+    }
+    return null;
+  }
+  const file_symbols = symbols_exports.by_file(ctx, file.id);
+  if (err.any(file_symbols)) return null;
+  for (const file_symbol of file_symbols) {
+    if (file_symbol.name === symbol_to_use.name) {
+      return { type: "internal", symbol_id: file_symbol.id, file_id: file.id };
+    }
+  }
+  return null;
+}
+function find_symbol_node(source_file, symbol) {
+  let result;
+  function visit(node) {
+    if (result) return;
+    if (matches_symbol(node, symbol)) {
+      result = node;
+      return;
+    }
+    ts11.forEachChild(node, visit);
+  }
+  visit(source_file);
+  return result;
+}
+function matches_symbol(node, symbol) {
+  if (symbol.name === "default") {
+    if (symbol.type === "function" && ts11.isFunctionDeclaration(node)) return has_default_modifier(node);
+    if (symbol.type === "class" && ts11.isClassDeclaration(node)) return has_default_modifier(node);
+    if (symbol.type === "variable") {
+      if (ts11.isExportAssignment(node) && !node.isExportEquals) return true;
+      if (ts11.isExportDeclaration(node) && node.exportClause && ts11.isNamedExports(node.exportClause)) {
+        return node.exportClause.elements.some((element) => element.name.text === "default");
+      }
+    }
+  }
+  if (symbol.type === "function") {
+    if (ts11.isVariableStatement(node)) {
+      const declarations = node.declarationList.declarations;
+      for (const decl of declarations) {
+        if (ts11.isIdentifier(decl.name) && decl.name.text === symbol.name) {
+          const initializer = decl.initializer;
+          if (initializer && (ts11.isArrowFunction(initializer) || ts11.isFunctionExpression(initializer))) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    if (ts11.isFunctionDeclaration(node)) {
+      return get_node_name(node) === symbol.name;
+    }
+    return false;
+  }
+  if (symbol.type === "class") {
+    if (!ts11.isClassDeclaration(node)) return false;
+    return get_node_name(node) === symbol.name;
+  }
+  if (symbol.type === "type") {
+    if (!ts11.isTypeAliasDeclaration(node) && !ts11.isInterfaceDeclaration(node) && !ts11.isEnumDeclaration(node)) return false;
+    return get_node_name(node) === symbol.name;
+  }
+  if (symbol.type === "variable") {
+    if (ts11.isVariableStatement(node)) {
+      const declarations = node.declarationList.declarations;
+      for (const decl of declarations) {
+        if (ts11.isIdentifier(decl.name) && decl.name.text === symbol.name) {
+          const initializer = decl.initializer;
+          if (!initializer || !ts11.isArrowFunction(initializer) && !ts11.isFunctionExpression(initializer)) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  if (symbol.type === "class_method") {
+    if (!ts11.isMethodDeclaration(node)) return false;
+    const method_name = get_node_name(node);
+    if (!method_name) return false;
+    const class_node = node.parent;
+    if (!class_node || !ts11.isClassDeclaration(class_node)) return false;
+    const class_name = get_node_name(class_node);
+    if (!class_name) return false;
+    return `${class_name}.${method_name}` === symbol.name;
+  }
+  if (symbol.type === "class_property") {
+    if (!ts11.isPropertyDeclaration(node)) return false;
+    const prop_name = get_node_name(node);
+    if (!prop_name) return false;
+    const class_node = node.parent;
+    if (!class_node || !ts11.isClassDeclaration(class_node)) return false;
+    const class_name = get_node_name(class_node);
+    if (!class_name) return false;
+    return `${class_name}.${prop_name}` === symbol.name;
+  }
+  return false;
+}
+function get_node_name(node) {
+  if (!("name" in node)) return void 0;
+  const nodeWithName = node;
+  if (nodeWithName.name && ts11.isIdentifier(nodeWithName.name)) {
+    return nodeWithName.name.text;
+  }
+  return void 0;
+}
+function is_declaration(parent, identifier) {
+  if (!parent) return false;
+  if (ts11.isFunctionDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isClassDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isInterfaceDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isTypeAliasDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isEnumDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isVariableDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isParameter(parent) && parent.name === identifier) return true;
+  if (ts11.isPropertyDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isMethodDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isTypeParameterDeclaration(parent) && parent.name === identifier) return true;
+  if (ts11.isImportClause(parent) && parent.name === identifier) return true;
+  if (ts11.isImportSpecifier(parent) && (parent.name === identifier || parent.propertyName === identifier)) return true;
+  if (ts11.isNamespaceImport(parent) && parent.name === identifier) return true;
+  return false;
+}
+function create_internal_link(ctx, from_symbol, resolution) {
+  const existing = symbol_internal_links_exports.exists(ctx, {
+    from_symbol_id: from_symbol.id,
+    to_symbol_id: resolution.symbol_id
+  });
+  if (err.any(existing)) return existing;
+  if (existing) return;
+  return symbol_internal_links_exports.insert(ctx, {
+    from_file_id: from_symbol.file_id,
+    to_file_id: resolution.file_id,
+    from_symbol_id: from_symbol.id,
+    to_symbol_id: resolution.symbol_id,
+    state: "pending"
+  });
+}
+function create_external_link(ctx, from_symbol, resolution) {
+  const existing = symbol_external_links_exports.exists(ctx, {
+    symbol_id: from_symbol.id,
+    external_import_id: resolution.external_import_id
+  });
+  if (err.any(existing)) return existing;
+  if (existing) return;
+  return symbol_external_links_exports.insert(ctx, {
+    symbol_id: from_symbol.id,
+    external_import_id: resolution.external_import_id
+  });
+}
+
+// src/update/index.ts
+async function update6(ctx) {
+  await track_changes(ctx);
+  await sync_external_dependencies(ctx);
+  await scan_files(ctx);
+  await link_imports(ctx);
+  await link_symbols(ctx);
+}
+
+// src/counts.ts
+import { count } from "drizzle-orm";
+var counts = safe_query("counts", (ctx) => {
+  const symbol_counts = ctx.db.select({ state: symbols.state, count: count() }).from(symbols).groupBy(symbols.state).all();
+  const file_counts = ctx.db.select({ state: files.state, count: count() }).from(files).groupBy(files.state).all();
+  const dir_counts = ctx.db.select({ state: directories.state, count: count() }).from(directories).groupBy(directories.state).all();
+  const dep_counts = ctx.db.select({ state: external_dependencies.state, count: count() }).from(external_dependencies).groupBy(external_dependencies.state).all();
+  return {
+    symbols: get_groups(symbol_counts, ["to_link", "to_describe", "ready"]),
+    files: get_groups(file_counts, ["to_scan", "to_describe", "ready"]),
+    directories: get_groups(dir_counts, ["to_describe", "ready"]),
+    dependencies: get_groups(dep_counts, ["to_describe", "ready"])
+  };
+});
+function get_groups(items, states) {
+  const groups = { total: 0 };
+  for (const state of states) groups[state] = 0;
+  for (const item of items) {
+    if (!states.includes(item.state)) continue;
+    groups[item.state] = (groups[item.state] || 0) + item.count;
+    groups.total += item.count;
+  }
+  return groups;
+}
+
+// src/files.ts
+function files_wiki(ctx) {
+  return {
+    get: (id) => get2(ctx, id),
+    search: (options) => search5(ctx, options),
+    set_description: (id, description) => set_description(ctx, id, description),
+    imported_by_file: (file_id, options) => imported_by_file(ctx, file_id, options),
+    importing_file: (file_id, options) => importing_file(ctx, file_id, options),
+    importing_dependency: (dependency_id, options) => importing_dependency(ctx, dependency_id, options)
+  };
+}
+function get2(ctx, id) {
+  return err.or_throw(files_exports.by_id(ctx, id)) ?? null;
+}
+function search5(ctx, options) {
+  return err.or_throw(files_exports.search(ctx, options));
+}
+function set_description(ctx, id, description) {
+  err.or_throw(files_exports.update(ctx, id, { description }));
+}
+function imported_by_file(ctx, file_id, options = {}) {
+  let imported_files = err.or_throw(files_exports.imported_by(ctx, file_id, options.select));
+  if (options.deep) {
+    imported_files = err.or_throw(
+      expand({
+        items: imported_files,
+        get_children: (file) => files_exports.imported_by(ctx, file.id, options.select),
+        get_key: (file) => file.id
+      })
+    );
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : imported_files.length;
+  return imported_files.slice(start, end);
+}
+function importing_file(ctx, file_id, options = {}) {
+  let importing_files = err.or_throw(files_exports.importing(ctx, file_id, options.select));
+  if (options.deep) {
+    importing_files = err.or_throw(
+      expand({
+        items: importing_files,
+        get_children: (file) => files_exports.importing(ctx, file.id, options.select),
+        get_key: (file) => file.id
+      })
+    );
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : importing_files.length;
+  return importing_files.slice(start, end);
+}
+function importing_dependency(ctx, dependency_id, options = {}) {
+  let files_using_dependency = err.or_throw(files_exports.using_dependency(ctx, dependency_id, options.select));
+  if (options.deep) {
+    files_using_dependency = err.or_throw(
+      expand({
+        items: files_using_dependency,
+        get_children: (file) => files_exports.importing(ctx, file.id, options.select),
+        get_key: (file) => file.id
+      })
+    );
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : files_using_dependency.length;
+  return files_using_dependency.slice(start, end);
+}
+
+// src/symbols.ts
+function symbols_wiki(ctx) {
+  return {
+    get: (id) => get3(ctx, id),
+    search: (options) => search6(ctx, options),
+    set_description: (id, description) => set_description2(ctx, id, description),
+    referencing_symbol: (symbol_id, options) => referencing_symbol(ctx, symbol_id, options),
+    referenced_by_symbol: (symbol_id, options) => referenced_by_symbol(ctx, symbol_id, options),
+    using_dependency: (dependency_id, options) => using_dependency3(ctx, dependency_id, options)
+  };
+}
+function get3(ctx, id) {
+  return err.or_throw(symbols_exports.by_id(ctx, id)) ?? null;
+}
+function search6(ctx, options) {
+  return err.or_throw(symbols_exports.search(ctx, options));
+}
+function set_description2(ctx, id, description) {
+  err.or_throw(symbols_exports.update(ctx, id, { description }));
+}
+function referenced_by_symbol(ctx, symbol_id, options = {}) {
+  let referenced_symbols = err.or_throw(symbols_exports.referenced_by(ctx, symbol_id, options.select));
+  if (options.deep) {
+    referenced_symbols = err.or_throw(
+      expand({
+        items: referenced_symbols,
+        get_children: (symbol) => symbols_exports.referenced_by(ctx, symbol.id, options.select),
+        get_key: (symbol) => symbol.id
+      })
+    );
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : referenced_symbols.length;
+  return referenced_symbols.slice(start, end);
+}
+function referencing_symbol(ctx, symbol_id, options = {}) {
+  let referencing_symbols = err.or_throw(symbols_exports.referencing(ctx, symbol_id, options.select));
+  if (options.deep) {
+    referencing_symbols = err.or_throw(
+      expand({
+        items: referencing_symbols,
+        get_children: (symbol) => symbols_exports.referencing(ctx, symbol.id, options.select),
+        get_key: (symbol) => symbol.id
+      })
+    );
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : referencing_symbols.length;
+  return referencing_symbols.slice(start, end);
+}
+function using_dependency3(ctx, dependency_id, options = {}) {
+  let symbols_using_dep = err.or_throw(symbols_exports.using_dependency(ctx, dependency_id, options.select));
+  if (options.deep) {
+    symbols_using_dep = err.or_throw(
+      expand({
+        items: symbols_using_dep,
+        get_children: (symbol) => symbols_exports.referencing(ctx, symbol.id, options.select),
+        get_key: (symbol) => symbol.id
+      })
+    );
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : symbols_using_dep.length;
+  return symbols_using_dep.slice(start, end);
+}
+
+// src/directories.ts
+function directories_wiki(ctx) {
+  return {
+    get: (id) => get4(ctx, id),
+    search: (options) => search7(ctx, options),
+    set_description: (id, description) => set_description3(ctx, id, description),
+    children: (parent_id, options) => children(ctx, parent_id, options),
+    files: (directory_id, options) => directory_files(ctx, directory_id, options)
+  };
+}
+function get4(ctx, id) {
+  return err.or_throw(directories_exports.by_id(ctx, id)) ?? null;
+}
+function search7(ctx, options) {
+  return err.or_throw(directories_exports.search(ctx, options));
+}
+function set_description3(ctx, id, description) {
+  err.or_throw(directories_exports.update(ctx, id, { description }));
+}
+function children(ctx, parent_id, options = {}) {
+  let child_directories = err.or_throw(directories_exports.search(ctx, { select: options.select, where: { parent_id }, limit: 1e4 }));
+  if (options.deep) {
+    child_directories = err.or_throw(
+      expand({
+        items: child_directories,
+        get_children: (dir) => directories_exports.search(ctx, { select: options.select, where: { parent_id: dir.id }, limit: 1e4 }),
+        get_key: (dir) => dir.id
+      })
+    );
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : child_directories.length;
+  return child_directories.slice(start, end);
+}
+function directory_files(ctx, directory_id, options = {}) {
+  let files_list = err.or_throw(files_exports.search(ctx, { select: options.select, where: { directory_id }, limit: 1e4 }));
+  if (options.deep) {
+    const all_subdirs = err.or_throw(
+      expand({
+        items: err.or_throw(directories_exports.search(ctx, { select: ["id"], where: { parent_id: directory_id }, limit: 1e4 })),
+        get_children: (dir) => directories_exports.search(ctx, { select: ["id"], where: { parent_id: dir.id }, limit: 1e4 }),
+        get_key: (dir) => dir.id
+      })
+    );
+    for (const subdir of all_subdirs) {
+      const subdir_files = err.or_throw(
+        files_exports.search(ctx, { select: options.select, where: { directory_id: subdir.id }, limit: 1e4 })
+      );
+      subdir_files.forEach((x) => files_list.push(x));
+    }
+  }
+  const start = options.offset ?? 0;
+  const end = options.limit ? start + options.limit : files_list.length;
+  return files_list.slice(start, end);
+}
+
+// src/dependencies.ts
+function dependencies_wiki(ctx) {
+  return {
+    get: (id) => get5(ctx, id),
+    search: (options) => search8(ctx, options),
+    set_description: (id, description) => set_description4(ctx, id, description),
+    used_by_file: (file_id, options) => used_by_file2(ctx, file_id, options),
+    used_by_symbol: (symbol_id, options) => used_by_symbol2(ctx, symbol_id, options)
+  };
+}
+function get5(ctx, id) {
+  return err.or_throw(external_dependencies_exports.by_id(ctx, id)) ?? null;
+}
+function search8(ctx, options) {
+  return err.or_throw(external_dependencies_exports.search(ctx, options));
+}
+function set_description4(ctx, id, description) {
+  err.or_throw(external_dependencies_exports.update(ctx, id, { description, state: "ready", error: null }));
+}
+function used_by_file2(ctx, file_id, options) {
+  return err.or_throw(external_dependencies_exports.used_by_file(ctx, file_id, options?.select));
+}
+function used_by_symbol2(ctx, symbol_id, options) {
+  return err.or_throw(external_dependencies_exports.used_by_symbol(ctx, symbol_id, options?.select));
+}
+
+// src/index.ts
+async function create(config) {
+  const ctx = await context_from_config(config);
+  return {
+    config,
+    update: () => update6(ctx),
+    counts: () => err.or_throw(counts(ctx)),
+    files: files_wiki(ctx),
+    symbols: symbols_wiki(ctx),
+    directories: directories_wiki(ctx),
+    dependencies: dependencies_wiki(ctx)
+  };
+}
+async function load(db_path) {
+  const ctx = await context_from_db(db_path);
+  const stored = ctx.db.select().from(schema_exports.configs).get();
+  const config = {
+    db_path,
+    project_path: stored.project_path,
+    description: stored.description ?? void 0,
+    package_json_path: stored.package_json_path ?? void 0,
+    node_modules_paths: stored.node_modules_paths ? JSON.parse(stored.node_modules_paths) : void 0
+  };
+  return {
+    config,
+    update: () => update6(ctx),
+    counts: () => err.or_throw(counts(ctx)),
+    files: files_wiki(ctx),
+    symbols: symbols_wiki(ctx),
+    directories: directories_wiki(ctx),
+    dependencies: dependencies_wiki(ctx)
+  };
+}
+
+// src/cli/commands/_common.ts
+var config_path = "codewiki.json";
+async function load_wiki() {
+  try {
+    const content = err.or_throw(env.read_file(config_path));
+    const raw_config = err.or_throw(parse_json(content));
+    const res = Config.safeParse(raw_config);
+    if (!res.success) throw err.new("invalid_config", { errors: res.error.issues });
+    const config = res.data;
+    if (env.file_exists(config.db_path)) return load(config.db_path);
+    return create(config);
+  } catch (error) {
+    if (error.type === "could_not_read_file") {
+      env.error(`Error: Configuration file ${config_path} not found`);
+    } else if (error.type === "invalid_json") {
+      env.error(`Error: Invalid JSON in ${config_path}`);
+    } else if (error.type === "invalid_config") {
+      env.error("Error: Invalid configuration");
+    } else if (error.message) {
+      env.error(`Error: ${error.message}`);
+    } else {
+      env.error(`Error: ${String(error)}`);
+    }
+    process.exit(1);
+  }
+}
+function parse_options(options_json, schema, context) {
+  let parsed_json;
+  try {
+    parsed_json = err.or_throw(parse_json(options_json));
+  } catch (error) {
+    env.log(`Error: Invalid JSON in ${context}`);
+    const error_msg = error.data?.reason?.message || "JSON parse error";
+    env.log(`  ${error_msg}`);
+    process.exit(1);
+  }
+  const validation_result = schema.safeParse(parsed_json);
+  if (!validation_result.success) {
+    env.log(`Error: Invalid options format in ${context}`);
+    env.log("");
+    for (const issue of validation_result.error.issues) {
+      const path6 = issue.path.length > 0 ? issue.path.join(".") : "root";
+      env.log(`  \u2022 ${path6}: ${issue.message}`);
+    }
+    env.log("");
+    env.log(`Run 'codewiki ${context.split(" ")[0]} --help' for usage information`);
+    process.exit(1);
+  }
+  return validation_result.data;
+}
+
+// src/cli/utils.ts
+import dedent from "dedent";
+function format_counts(counts2) {
+  const total_to_describe = Object.values(counts2).reduce((a, b) => a + b.to_describe, 0);
+  return dedent`
+    stats:
+      directories: ${count_text(counts2.directories)}
+      files: ${count_text(counts2.files)}
+      symbols: ${count_text(counts2.symbols)}
+      dependencies: ${count_text(counts2.dependencies)}
+
+    ${total_to_describe} items to describe, run \`codewiki describe\` to start describing the codebase
+  `;
+}
+function count_text({ total, ...states }) {
+  return `${total} (${Object.entries(states).map(([name, value]) => `${value} ${name.replace("_", " ")}`).join(", ")})`;
+}
+
+// src/cli/commands/update.ts
+var update7 = new Command("update");
+update7.description("Reads current files and updates the wiki database");
+update7.action(async () => {
+  const wiki = await load_wiki();
+  await wiki.update();
+  env.log("Update complete.\n");
+  const counts2 = wiki.counts();
+  const status2 = format_counts(counts2);
+  env.log(status2);
+});
+
+// src/cli/commands/status.ts
+import { Command as Command2 } from "commander";
+var status = new Command2("status");
+status.description("Show the status of the wiki");
+status.action(async () => {
+  const wiki = await load_wiki();
+  const counts2 = wiki.counts();
+  env.log(format_counts(counts2));
+});
+
+// src/cli/commands/describe.ts
+import dedent2 from "dedent";
+import { Command as Command3 } from "commander";
+var describe = new Command3("describe");
+describe.description("Show the next item to describe");
+describe.action(async () => {
+  const wiki = await load_wiki();
+  const next = get_next_to_describe(wiki);
+  if (!next) return env.log("All items are described!");
+  if (next.type === "dependency") return describe_dependency(next.entity);
+  env.log(
+    `All external dependencies are described, and we don't support describing other items yet (we are implementing the right order ...). You are done for now!`
+  );
+});
+function describe_dependency(dep) {
+  env.log(dedent2`
+    Your task is to describe the following dependency:
+
+    import { ${dep.name} } from '${dep.package}${dep.subpath || ""}'
+
+    package: ${dep.package}
+    version: ${dep.version}
+    github: ${dep.github_repo || "N/A"}
+
+    Write a concise developer documentation on the usage of this \`${dep.name}\` into a markdown file, then run the following command to save the description:
+      \`codewiki dependencies set-description ${dep.id} <markdown-file>\`
+  `);
+}
+function get_next_to_describe(wiki) {
+  const deps = wiki.dependencies.search({
+    where: { state: "to_describe" },
+    limit: 1,
+    select: ["id", "package", "subpath", "name", "version", "github_repo"]
+  });
+  if (deps.length > 0) {
+    return { type: "dependency", entity: deps[0] };
+  }
+  const symbols4 = wiki.symbols.search({
+    where: { state: "to_describe" },
+    limit: 1,
+    select: ["id", "name", "type", "file_id", "is_exported"]
+  });
+  if (symbols4.length > 0) {
+    return { type: "symbol", entity: symbols4[0] };
+  }
+  const files5 = wiki.files.search({
+    where: { state: "to_describe" },
+    limit: 1,
+    select: ["id", "path"]
+  });
+  if (files5.length > 0) {
+    return { type: "file", entity: files5[0] };
+  }
+  const directories4 = wiki.directories.search({
+    where: { state: "to_describe" },
+    limit: 1,
+    select: ["id", "path"]
+  });
+  if (directories4.length > 0) {
+    return { type: "directory", entity: directories4[0] };
+  }
+  return null;
+}
+
+// src/cli/commands/files/index.ts
+import { Command as Command10 } from "commander";
+import dedent3 from "dedent";
+
+// src/cli/commands/files/get.ts
+import { Command as Command4 } from "commander";
+var get6 = new Command4("get");
+get6.description("Get a file by ID");
+get6.argument("<id>", "File ID");
+get6.action(async (id) => {
+  const wiki = await load_wiki();
+  const file = wiki.files.get(Number(id));
+  env.log(JSON.stringify(file, null, 2));
+});
+
+// src/cli/commands/files/search.ts
+import { Command as Command5 } from "commander";
+var search9 = new Command5("search");
+search9.description("Search files with JSON options");
+search9.argument("<options>", "JSON options for search");
+search9.action(async (options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, FileSearchOptions, "files search");
+  const results = wiki.files.search(options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/files/set-description.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { Command as Command6 } from "commander";
+var set_description5 = new Command6("set-description");
+set_description5.description("Set description for a file");
+set_description5.argument("<file-id>", "File ID");
+set_description5.argument("<markdown-file>", "Path to markdown file");
+set_description5.action(async (id, file) => {
+  const wiki = await load_wiki();
+  try {
+    const content = readFileSync2(file, "utf-8");
+    wiki.files.set_description(Number(id), content);
+    env.log("Description saved. Run `codewiki describe` to describe the next item.");
+  } catch (err2) {
+    env.error(`Error: ${err2.message}`);
+    env.exit(1);
+  }
+});
+
+// src/cli/commands/files/imported-by-file.ts
+import { Command as Command7 } from "commander";
+var imported_by_file2 = new Command7("imported-by-file");
+imported_by_file2.description("Files imported by the given file");
+imported_by_file2.argument("<file-id>", "File ID");
+imported_by_file2.argument("<options>", "JSON options");
+imported_by_file2.action(async (file_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, FileRelationOptions, "files imported-by-file");
+  const results = wiki.files.imported_by_file(Number(file_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/files/importing-file.ts
+import { Command as Command8 } from "commander";
+var importing_file2 = new Command8("importing-file");
+importing_file2.description("Files importing the given file");
+importing_file2.argument("<file-id>", "File ID");
+importing_file2.argument("<options>", "JSON options");
+importing_file2.action(async (file_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, FileRelationOptions, "files importing-file");
+  const results = wiki.files.importing_file(Number(file_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/files/importing-dependency.ts
+import { Command as Command9 } from "commander";
+var importing_dependency2 = new Command9("importing-dependency");
+importing_dependency2.description("Files importing the given dependency");
+importing_dependency2.argument("<dep-id>", "Dependency ID");
+importing_dependency2.argument("<options>", "JSON options");
+importing_dependency2.action(async (dep_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, FileRelationOptions, "files importing-dependency");
+  const results = wiki.files.importing_dependency(Number(dep_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/files/index.ts
+var files3 = new Command10("files");
+files3.description("Explore files");
+files3.addCommand(get6);
+files3.addCommand(search9);
+files3.addCommand(set_description5);
+files3.addCommand(imported_by_file2);
+files3.addCommand(importing_file2);
+files3.addCommand(importing_dependency2);
+files3.addHelpText("after", dedent3`
+  
+  <search-options> is a JSON string following the type SearchOptions:
+  
+  type FileField = "id" | "directory_id" | "path" | "description" | "state" | "error"
+  type SearchOptions = {
+    select?: Array<FileField>
+    limit?: number
+    offset?: number
+    where?: Record<FileField, string | { contains: string } | { starts_with: string } | { ends_with: string }>
+    order_by?: [FileField, 'asc' | 'desc']
+  }
+  
+  <relation-options> is a JSON string following the type RelationOptions:
+  
+  type RelationOptions = {
+    select?: Array<FileField>
+    limit?: number
+    offset?: number
+    deep?: boolean
+  }
+  
+  Examples:
+    codewiki files search '{"limit": 10}'
+    codewiki files search '{"where": {"state": "ready"}, "limit": 5}'
+    codewiki files search '{"where": {"path": {"contains": "test"}}, "limit": 10}'
+    codewiki files imported-by-file 123 '{"limit": 10}'
+`);
+
+// src/cli/commands/symbols/index.ts
+import { Command as Command17 } from "commander";
+import dedent4 from "dedent";
+
+// src/cli/commands/symbols/get.ts
+import { Command as Command11 } from "commander";
+var get7 = new Command11("get");
+get7.description("Get a symbol by ID");
+get7.argument("<id>", "Symbol ID");
+get7.action(async (id) => {
+  const wiki = await load_wiki();
+  const symbol = wiki.symbols.get(Number(id));
+  env.log(JSON.stringify(symbol, null, 2));
+});
+
+// src/cli/commands/symbols/search.ts
+import { Command as Command12 } from "commander";
+var search10 = new Command12("search");
+search10.description("Search symbols with JSON options");
+search10.argument("<options>", "JSON options");
+search10.action(async (options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, SymbolSearchOptions, "symbols search");
+  const results = wiki.symbols.search(options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/symbols/set-description.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { Command as Command13 } from "commander";
+var set_description6 = new Command13("set-description");
+set_description6.description("Set description for a symbol");
+set_description6.argument("<symbol-id>", "Symbol ID");
+set_description6.argument("<markdown-file>", "Path to markdown file");
+set_description6.action(async (id, file) => {
+  const wiki = await load_wiki();
+  try {
+    const content = readFileSync3(file, "utf-8");
+    wiki.symbols.set_description(Number(id), content);
+    env.log("Description saved. Run `codewiki describe` to describe the next item.");
+  } catch (err2) {
+    env.error(`Error: ${err2.message}`);
+    env.exit(1);
+  }
+});
+
+// src/cli/commands/symbols/referencing-symbol.ts
+import { Command as Command14 } from "commander";
+var referencing_symbol2 = new Command14("referencing-symbol");
+referencing_symbol2.description("Symbols referencing the given symbol");
+referencing_symbol2.argument("<symbol-id>", "Symbol ID");
+referencing_symbol2.argument("<options>", "JSON options");
+referencing_symbol2.action(async (symbol_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, SymbolRelationOptions, "symbols referencing-symbol");
+  const results = wiki.symbols.referencing_symbol(Number(symbol_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/symbols/referenced-by-symbol.ts
+import { Command as Command15 } from "commander";
+var referenced_by_symbol2 = new Command15("referenced-by-symbol");
+referenced_by_symbol2.description("Symbols referenced by the given symbol");
+referenced_by_symbol2.argument("<symbol-id>", "Symbol ID");
+referenced_by_symbol2.argument("<options>", "JSON options");
+referenced_by_symbol2.action(async (symbol_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, SymbolRelationOptions, "symbols referenced-by-symbol");
+  const results = wiki.symbols.referenced_by_symbol(Number(symbol_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/symbols/using-dependency.ts
+import { Command as Command16 } from "commander";
+var using_dependency4 = new Command16("using-dependency");
+using_dependency4.description("Symbols using the given dependency");
+using_dependency4.argument("<dep-id>", "Dependency ID");
+using_dependency4.argument("<options>", "JSON options");
+using_dependency4.action(async (dep_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, SymbolRelationOptions, "symbols using-dependency");
+  const results = wiki.symbols.using_dependency(Number(dep_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/symbols/index.ts
+var symbols3 = new Command17("symbols");
+symbols3.description("Explore symbols");
+symbols3.addCommand(get7);
+symbols3.addCommand(search10);
+symbols3.addCommand(set_description6);
+symbols3.addCommand(referencing_symbol2);
+symbols3.addCommand(referenced_by_symbol2);
+symbols3.addCommand(using_dependency4);
+symbols3.addHelpText("after", dedent4`
+  
+  <search-options> is a JSON string following the type SearchOptions:
+  
+  type SymbolField = "id" | "file_id" | "type" | "name" | "text" | "meta" | "description" | "is_exported" | "state" | "error"
+  type SearchOptions = {
+    select?: Array<SymbolField>
+    limit?: number
+    offset?: number
+    where?: Record<SymbolField, string | { contains: string } | { starts_with: string } | { ends_with: string }>
+    order_by?: [SymbolField, 'asc' | 'desc']
+  }
+  
+  <relation-options> is a JSON string following the type RelationOptions:
+  
+  type RelationOptions = {
+    select?: Array<SymbolField>
+    limit?: number
+    offset?: number
+    deep?: boolean
+  }
+  
+  Examples:
+    codewiki symbols search '{"limit": 10}'
+    codewiki symbols search '{"where": {"type": "function"}, "limit": 5}'
+    codewiki symbols search '{"where": {"name": {"starts_with": "test"}}, "limit": 10}'
+    codewiki symbols referencing-symbol 123 '{"limit": 10}'
+`);
+
+// src/cli/commands/directories/index.ts
+import { Command as Command23 } from "commander";
+import dedent5 from "dedent";
+
+// src/cli/commands/directories/get.ts
+import { Command as Command18 } from "commander";
+var get8 = new Command18("get");
+get8.description("Get a directory by ID");
+get8.argument("<id>", "Directory ID");
+get8.action(async (id) => {
+  const wiki = await load_wiki();
+  const directory = wiki.directories.get(Number(id));
+  env.log(JSON.stringify(directory, null, 2));
+});
+
+// src/cli/commands/directories/search.ts
+import { Command as Command19 } from "commander";
+var search11 = new Command19("search");
+search11.description("Search directories with JSON options");
+search11.argument("<options>", "JSON options");
+search11.action(async (options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, DirectorySearchOptions, "directories search");
+  const results = wiki.directories.search(options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/directories/set-description.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { Command as Command20 } from "commander";
+var set_description7 = new Command20("set-description");
+set_description7.description("Set description for a directory");
+set_description7.argument("<directory-id>", "Directory ID");
+set_description7.argument("<markdown-file>", "Path to markdown file");
+set_description7.action(async (id, file) => {
+  const wiki = await load_wiki();
+  try {
+    const content = readFileSync4(file, "utf-8");
+    wiki.directories.set_description(Number(id), content);
+    env.log("Description saved. Run `codewiki describe` to describe the next item.");
+  } catch (err2) {
+    env.error(`Error: ${err2.message}`);
+    env.exit(1);
+  }
+});
+
+// src/cli/commands/directories/children.ts
+import { Command as Command21 } from "commander";
+var children2 = new Command21("children");
+children2.description("Child directories of the given directory");
+children2.argument("<parent-id>", "Parent directory ID");
+children2.argument("<options>", "JSON options");
+children2.action(async (parent_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, DirectoryRelationOptions, "directories children");
+  const results = wiki.directories.children(Number(parent_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/directories/files.ts
+import { Command as Command22 } from "commander";
+var files4 = new Command22("files");
+files4.description("Files in the given directory");
+files4.argument("<directory-id>", "Directory ID");
+files4.argument("<options>", "JSON options");
+files4.action(async (directory_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, FileRelationOptions, "directories files");
+  const results = wiki.directories.files(Number(directory_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/directories/index.ts
+var directories3 = new Command23("directories");
+directories3.description("Explore directories");
+directories3.addCommand(get8);
+directories3.addCommand(search11);
+directories3.addCommand(set_description7);
+directories3.addCommand(children2);
+directories3.addCommand(files4);
+directories3.addHelpText("after", dedent5`
+  
+  <search-options> is a JSON string following the type SearchOptions:
+  
+  type DirectoryField = "id" | "parent_id" | "path" | "description" | "state" | "error"
+  type SearchOptions = {
+    select?: Array<DirectoryField>
+    limit?: number
+    offset?: number
+    where?: Record<DirectoryField, string | { contains: string } | { starts_with: string } | { ends_with: string }>
+    order_by?: [DirectoryField, 'asc' | 'desc']
+  }
+  
+  <relation-options> is a JSON string following the type RelationOptions:
+  
+  type RelationOptions = {
+    select?: Array<DirectoryField> | Array<FileField>
+    limit?: number
+    offset?: number
+    deep?: boolean
+  }
+  
+  Examples:
+    codewiki directories search '{"limit": 10}'
+    codewiki directories search '{"where": {"path": {"contains": "src"}}, "limit": 5}'
+    codewiki directories children 123 '{"limit": 10, "deep": true}'
+    codewiki directories files 123 '{"limit": 20}'
+`);
+
+// src/cli/commands/dependencies/index.ts
+import { Command as Command29 } from "commander";
+import dedent6 from "dedent";
+
+// src/cli/commands/dependencies/get.ts
+import { Command as Command24 } from "commander";
+var get9 = new Command24("get");
+get9.description("Get a dependency by ID");
+get9.argument("<id>", "Dependency ID");
+get9.action(async (id) => {
+  const wiki = await load_wiki();
+  const dependency = wiki.dependencies.get(Number(id));
+  env.log(JSON.stringify(dependency, null, 2));
+});
+
+// src/cli/commands/dependencies/search.ts
+import { Command as Command25 } from "commander";
+var search12 = new Command25("search");
+search12.description("Search dependencies with JSON options");
+search12.argument("<options>", "JSON options");
+search12.action(async (options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, DependencySearchOptions, "dependencies search");
+  const results = wiki.dependencies.search(options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/dependencies/set-description.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { Command as Command26 } from "commander";
+var set_description8 = new Command26("set-description");
+set_description8.description("Set description for a dependency");
+set_description8.argument("<dependency-id>", "Dependency ID");
+set_description8.argument("<markdown-file>", "Path to markdown file");
+set_description8.action(async (id, file) => {
+  const wiki = await load_wiki();
+  try {
+    const content = readFileSync5(file, "utf-8");
+    wiki.dependencies.set_description(Number(id), content);
+    env.log("Description saved. Run `codewiki describe` to describe the next item.");
+  } catch (err2) {
+    env.error(`Error: ${err2.message}`);
+    env.exit(1);
+  }
+});
+
+// src/cli/commands/dependencies/used-by-file.ts
+import { Command as Command27 } from "commander";
+var used_by_file3 = new Command27("used-by-file");
+used_by_file3.description("Dependencies used by the given file");
+used_by_file3.argument("<file-id>", "File ID");
+used_by_file3.argument("<options>", "JSON options");
+used_by_file3.action(async (file_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, DependencySelectOptions, "dependencies used-by-file");
+  const results = wiki.dependencies.used_by_file(Number(file_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/dependencies/used-by-symbol.ts
+import { Command as Command28 } from "commander";
+var used_by_symbol3 = new Command28("used-by-symbol");
+used_by_symbol3.description("Dependencies used by the given symbol");
+used_by_symbol3.argument("<symbol-id>", "Symbol ID");
+used_by_symbol3.argument("<options>", "JSON options");
+used_by_symbol3.action(async (symbol_id, options_json) => {
+  const wiki = await load_wiki();
+  const options = parse_options(options_json, DependencySelectOptions, "dependencies used-by-symbol");
+  const results = wiki.dependencies.used_by_symbol(Number(symbol_id), options);
+  env.log(JSON.stringify(results, null, 2));
+});
+
+// src/cli/commands/dependencies/index.ts
+var dependencies = new Command29("dependencies");
+dependencies.description("Explore dependencies");
+dependencies.addCommand(get9);
+dependencies.addCommand(search12);
+dependencies.addCommand(set_description8);
+dependencies.addCommand(used_by_file3);
+dependencies.addCommand(used_by_symbol3);
+dependencies.addHelpText("after", dedent6`
+  
+  <search-options> is a JSON string following the type SearchOptions:
+  
+  type DependencyField = "id" | "package" | "subpath" | "name" | "version" | "github_repo" | "is_builtin" | "description" | "state" | "error"
+  type SearchOptions = {
+    select?: Array<DependencyField>
+    limit?: number
+    offset?: number
+    where?: Record<DependencyField, string | { contains: string } | { starts_with: string } | { ends_with: string }>
+    order_by?: [DependencyField, 'asc' | 'desc']
+  }
+  
+  <select-options> is a JSON string following the type SelectOptions:
+  
+  type SelectOptions = {
+    select?: Array<DependencyField>
+    limit?: number
+    offset?: number
+  }
+  
+  Examples:
+    codewiki dependencies search '{"limit": 10}'
+    codewiki dependencies search '{"where": {"is_builtin": false}, "limit": 5}'
+    codewiki dependencies search '{"where": {"package": {"starts_with": "@types"}}, "limit": 10}'
+    codewiki dependencies used-by-file 123 '{"limit": 10}'
+`);
+
+// src/cli/commands/index.ts
+var commands = [update7, status, describe, files3, symbols3, directories3, dependencies];
+
+// src/cli/index.ts
+async function run(argv) {
+  const program = new Command30();
+  program.name("codewiki").description("Describe and explore TypeScript codebases").version("0.0.1");
+  for (const cmd of commands) program.addCommand(cmd);
+  return program.parseAsync(argv, { from: "user" });
+}
+
+// src/cli/bin.ts
+run(env.argv().slice(2)).catch((error) => {
+  env.error(error.message || String(error));
+  env.exit(1);
+});
+//# sourceMappingURL=bin.js.map