@webneat/codewiki 0.0.5 → 0.0.7

package/dist/cli.cjs

@@ -578,7 +578,7 @@ var symbols2 = {
   where: {}
 };
 var external_dependencies2 = {
-  select: ["id", "package", "subpath", "name", "state", "error"],
+  select: ["id", "package", "subpath", "name", "is_builtin", "state", "error"],
   order_by: ["id", "asc"],
   limit: 20,
   offset: 0,
@@ -1204,12 +1204,6 @@ async function create_context(sqlite, db6, config) {
   );
   return ctx;
 }
-async function context_from_config(config) {
-  const sqlite = new import_better_sqlite3.default(config.db_path);
-  sqlite.pragma("foreign_keys = ON");
-  const db6 = (0, import_better_sqlite32.drizzle)(sqlite, { schema: schema_exports });
-  return create_context(sqlite, db6, config);
-}
 async function context_from_db(db_path) {
   const sqlite = new import_better_sqlite3.default(db_path);
   sqlite.pragma("foreign_keys = ON");
@@ -1266,6 +1260,7 @@ async function get_github_repo(node_modules_paths, package_name) {
 // src/cli/env.ts
 var env = {
   read_file,
+  cwd: () => process.cwd(),
   file_exists: (path6) => (0, import_node_fs2.existsSync)(path6),
   argv: () => process.argv,
   log: (...args) => console.log(...args),
@@ -1274,120 +1269,7 @@ var env = {
 };
 
 // src/cli/commands/_common.ts
-var import_zod2 = require("zod");
-
-// src/cli/schema.ts
 var import_zod = require("zod");
-var Config = import_zod.z.object({
-  db_path: import_zod.z.string().describe("Path to SQLite database"),
-  project_path: import_zod.z.string().describe("Path to TypeScript project"),
-  description: import_zod.z.string().optional(),
-  package_json_path: import_zod.z.string().optional(),
-  node_modules_paths: import_zod.z.array(import_zod.z.string()).optional()
-});
-var StringFilter = import_zod.z.union([
-  import_zod.z.string(),
-  import_zod.z.object({ contains: import_zod.z.string() }),
-  import_zod.z.object({ starts_with: import_zod.z.string() }),
-  import_zod.z.object({ ends_with: import_zod.z.string() })
-]);
-var OrderDirection = import_zod.z.enum(["asc", "desc"]);
-var FileField = import_zod.z.enum(["id", "directory_id", "path", "description", "state", "error"]);
-var FileState = import_zod.z.enum(["to_scan", "to_describe", "ready"]);
-var FileSearchOptions = import_zod.z.object({
-  select: import_zod.z.array(FileField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional(),
-  where: import_zod.z.object({
-    id: import_zod.z.number().optional(),
-    directory_id: import_zod.z.number().optional(),
-    path: StringFilter.optional(),
-    description: StringFilter.optional(),
-    state: import_zod.z.union([FileState, import_zod.z.object({ contains: import_zod.z.string() })]).optional(),
-    error: StringFilter.optional()
-  }).optional(),
-  order_by: import_zod.z.tuple([FileField, OrderDirection]).optional()
-});
-var FileRelationOptions = import_zod.z.object({
-  select: import_zod.z.array(FileField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional(),
-  deep: import_zod.z.boolean().optional()
-});
-var SymbolField = import_zod.z.enum(["id", "file_id", "type", "name", "text", "meta", "description", "is_exported", "state", "error"]);
-var SymbolType = import_zod.z.enum(["function", "class", "class_method", "class_property", "variable", "type"]);
-var SymbolState = import_zod.z.enum(["to_link", "to_describe", "ready"]);
-var SymbolSearchOptions = import_zod.z.object({
-  select: import_zod.z.array(SymbolField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional(),
-  where: import_zod.z.object({
-    id: import_zod.z.number().optional(),
-    file_id: import_zod.z.number().optional(),
-    type: import_zod.z.union([SymbolType, import_zod.z.object({ contains: import_zod.z.string() })]).optional(),
-    name: StringFilter.optional(),
-    text: StringFilter.optional(),
-    meta: StringFilter.optional(),
-    description: StringFilter.optional(),
-    is_exported: import_zod.z.boolean().optional(),
-    state: import_zod.z.union([SymbolState, import_zod.z.object({ contains: import_zod.z.string() })]).optional(),
-    error: StringFilter.optional()
-  }).optional(),
-  order_by: import_zod.z.tuple([SymbolField, OrderDirection]).optional()
-});
-var SymbolRelationOptions = import_zod.z.object({
-  select: import_zod.z.array(SymbolField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional(),
-  deep: import_zod.z.boolean().optional()
-});
-var DirectoryField = import_zod.z.enum(["id", "parent_id", "path", "description", "state", "error"]);
-var DirectoryState = import_zod.z.enum(["to_describe", "ready"]);
-var DirectorySearchOptions = import_zod.z.object({
-  select: import_zod.z.array(DirectoryField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional(),
-  where: import_zod.z.object({
-    id: import_zod.z.number().optional(),
-    parent_id: import_zod.z.number().optional(),
-    path: StringFilter.optional(),
-    description: StringFilter.optional(),
-    state: import_zod.z.union([DirectoryState, import_zod.z.object({ contains: import_zod.z.string() })]).optional(),
-    error: StringFilter.optional()
-  }).optional(),
-  order_by: import_zod.z.tuple([DirectoryField, OrderDirection]).optional()
-});
-var DirectoryRelationOptions = import_zod.z.object({
-  select: import_zod.z.array(DirectoryField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional(),
-  deep: import_zod.z.boolean().optional()
-});
-var DependencyField = import_zod.z.enum(["id", "package", "subpath", "name", "version", "github_repo", "is_builtin", "description", "state", "error"]);
-var DependencyState = import_zod.z.enum(["to_describe", "ready"]);
-var DependencySearchOptions = import_zod.z.object({
-  select: import_zod.z.array(DependencyField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional(),
-  where: import_zod.z.object({
-    id: import_zod.z.number().optional(),
-    package: StringFilter.optional(),
-    subpath: StringFilter.optional(),
-    name: StringFilter.optional(),
-    version: StringFilter.optional(),
-    github_repo: StringFilter.optional(),
-    is_builtin: import_zod.z.boolean().optional(),
-    description: StringFilter.optional(),
-    state: import_zod.z.union([DependencyState, import_zod.z.object({ contains: import_zod.z.string() })]).optional(),
-    error: StringFilter.optional()
-  }).optional(),
-  order_by: import_zod.z.tuple([DependencyField, OrderDirection]).optional()
-});
-var DependencySelectOptions = import_zod.z.object({
-  select: import_zod.z.array(DependencyField).optional(),
-  limit: import_zod.z.number().int().positive().optional(),
-  offset: import_zod.z.number().int().nonnegative().optional()
-});
 
 // src/update/track_changes.ts
 var import_node_path3 = __toESM(require("path"), 1);
@@ -2485,6 +2367,21 @@ async function update6(ctx) {
   await link_symbols(ctx);
 }
 
+// src/update_config.ts
+function update_config(ctx, config, updates) {
+  if (Object.keys(updates).length === 0) return;
+  const new_config = { ...config, ...updates };
+  err.or_throw(
+    configs_exports.upsert(ctx, {
+      project_path: new_config.project_path,
+      description: new_config.description ?? null,
+      package_json_path: new_config.package_json_path ?? null,
+      node_modules_paths: new_config.node_modules_paths ? JSON.stringify(new_config.node_modules_paths) : null
+    })
+  );
+  Object.assign(config, updates);
+}
+
 // src/counts.ts
 var import_drizzle_orm13 = require("drizzle-orm");
 function counts(ctx) {
@@ -2800,19 +2697,6 @@ function directories_to_describe(ctx, limit) {
 }
 
 // src/index.ts
-async function create(config) {
-  const ctx = await context_from_config(config);
-  return {
-    config,
-    update: () => update6(ctx),
-    counts: () => counts(ctx),
-    to_describe: (limit) => to_describe(ctx, limit),
-    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();
@@ -2825,6 +2709,7 @@ async function load(db_path) {
   };
   return {
     config,
+    update_config: (updates) => update_config(ctx, config, updates),
     update: () => update6(ctx),
     counts: () => counts(ctx),
     to_describe: (limit) => to_describe(ctx, limit),
@@ -2836,30 +2721,18 @@ async function load(db_path) {
 }
 
 // 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 get_db_path(...args) {
+  const cmd = args[args.length - 1];
+  return cmd.optsWithGlobals().db;
+}
+async function load_wiki(db_path) {
+  if (!env.file_exists(db_path)) {
+    env.error(`Error: No wiki found at ${db_path}`);
+    env.error(`Run \`codewiki init\` to create one.`);
+    env.exit(1);
+    return void 0;
   }
+  return load(db_path);
 }
 function parse_options(options_json, schema, context) {
   let parsed_json;
@@ -2907,8 +2780,8 @@ function count_text({ total, ...states }) {
 // src/cli/commands/update.ts
 var update7 = new import_commander.Command("update");
 update7.description("Reads current files and updates the wiki database");
-update7.action(async () => {
-  const wiki = await load_wiki();
+update7.action(async (...args) => {
+  const wiki = await load_wiki(get_db_path(...args));
   await wiki.update();
   env.log("Update complete.\n");
   const counts2 = wiki.counts();
@@ -2920,8 +2793,8 @@ update7.action(async () => {
 var import_commander2 = require("commander");
 var status = new import_commander2.Command("status");
 status.description("Show the status of the wiki");
-status.action(async () => {
-  const wiki = await load_wiki();
+status.action(async (...args) => {
+  const wiki = await load_wiki(get_db_path(...args));
   const counts2 = wiki.counts();
   env.log(format_counts(counts2));
 });
@@ -2931,14 +2804,25 @@ var import_dedent2 = __toESM(require("dedent"), 1);
 var import_commander3 = require("commander");
 var describe = new import_commander3.Command("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!`
-  );
+describe.action(async (...args) => {
+  const wiki = await load_wiki(get_db_path(...args));
+  const result = wiki.to_describe(1);
+  if (result.type === "none") {
+    return env.log("All items are described!");
+  }
+  if (result.type === "dependencies" && result.items.length > 0) {
+    return describe_dependency(result.items[0]);
+  }
+  if (result.type === "symbols" && result.items.length > 0) {
+    return describe_symbol(wiki, result.items[0]);
+  }
+  if (result.type === "files" && result.items.length > 0) {
+    return describe_file(result.items[0]);
+  }
+  if (result.type === "directories" && result.items.length > 0) {
+    return describe_directory(result.items[0]);
+  }
+  env.log("No items to describe.");
 });
 function describe_dependency(dep) {
   env.log(import_dedent2.default`
@@ -2954,40 +2838,42 @@ function describe_dependency(dep) {
       \`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;
+function describe_symbol(wiki, sym) {
+  const file = wiki.files.get(sym.file_id);
+  env.log(import_dedent2.default`
+    Your task is to describe the following symbol:
+
+    name: ${sym.name}
+    type: ${sym.type}
+    file: ${file?.path || "unknown"}
+    exported: ${sym.is_exported}
+
+    Write a concise developer documentation for this ${sym.type} into a markdown file, then run:
+
+    codewiki symbols set-description ${sym.id} <markdown-file>
+  `);
+}
+function describe_file(file) {
+  env.log(import_dedent2.default`
+    Your task is to describe the following file:
+
+    path: ${file.path}
+
+    Write a concise description of this file's purpose and contents into a markdown file, then run:
+
+    codewiki files set-description ${file.id} <markdown-file>
+  `);
+}
+function describe_directory(dir) {
+  env.log(import_dedent2.default`
+    Your task is to describe the following directory:
+
+    path: ${dir.path}
+
+    Write a concise description of this directory's purpose and contents into a markdown file, then run:
+
+    codewiki directories set-description ${dir.id} <markdown-file>
+  `);
 }
 
 // src/cli/commands/files/index.ts
@@ -2999,19 +2885,136 @@ var import_commander4 = require("commander");
 var get6 = new import_commander4.Command("get");
 get6.description("Get a file by ID");
 get6.argument("<id>", "File ID");
-get6.action(async (id) => {
-  const wiki = await load_wiki();
+get6.action(async (...args) => {
+  const [id] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const file = wiki.files.get(Number(id));
   env.log(JSON.stringify(file, null, 2));
 });
 
 // src/cli/commands/files/search.ts
 var import_commander5 = require("commander");
+
+// src/cli/schema.ts
+var import_zod2 = require("zod");
+var Config = import_zod2.z.object({
+  db_path: import_zod2.z.string().describe("Path to SQLite database"),
+  project_path: import_zod2.z.string().describe("Path to TypeScript project"),
+  description: import_zod2.z.string().optional(),
+  package_json_path: import_zod2.z.string().optional(),
+  node_modules_paths: import_zod2.z.array(import_zod2.z.string()).optional()
+});
+var StringFilter = import_zod2.z.union([
+  import_zod2.z.string(),
+  import_zod2.z.object({ contains: import_zod2.z.string() }),
+  import_zod2.z.object({ starts_with: import_zod2.z.string() }),
+  import_zod2.z.object({ ends_with: import_zod2.z.string() })
+]);
+var OrderDirection = import_zod2.z.enum(["asc", "desc"]);
+var FileField = import_zod2.z.enum(["id", "directory_id", "path", "description", "state", "error"]);
+var FileState = import_zod2.z.enum(["to_scan", "to_describe", "ready"]);
+var FileSearchOptions = import_zod2.z.object({
+  select: import_zod2.z.array(FileField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional(),
+  where: import_zod2.z.object({
+    id: import_zod2.z.number().optional(),
+    directory_id: import_zod2.z.number().optional(),
+    path: StringFilter.optional(),
+    description: StringFilter.optional(),
+    state: import_zod2.z.union([FileState, import_zod2.z.object({ contains: import_zod2.z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: import_zod2.z.tuple([FileField, OrderDirection]).optional()
+});
+var FileRelationOptions = import_zod2.z.object({
+  select: import_zod2.z.array(FileField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional(),
+  deep: import_zod2.z.boolean().optional()
+});
+var SymbolField = import_zod2.z.enum(["id", "file_id", "type", "name", "text", "meta", "description", "is_exported", "state", "error"]);
+var SymbolType = import_zod2.z.enum(["function", "class", "class_method", "class_property", "variable", "type"]);
+var SymbolState = import_zod2.z.enum(["to_link", "to_describe", "ready"]);
+var SymbolSearchOptions = import_zod2.z.object({
+  select: import_zod2.z.array(SymbolField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional(),
+  where: import_zod2.z.object({
+    id: import_zod2.z.number().optional(),
+    file_id: import_zod2.z.number().optional(),
+    type: import_zod2.z.union([SymbolType, import_zod2.z.object({ contains: import_zod2.z.string() })]).optional(),
+    name: StringFilter.optional(),
+    text: StringFilter.optional(),
+    meta: StringFilter.optional(),
+    description: StringFilter.optional(),
+    is_exported: import_zod2.z.boolean().optional(),
+    state: import_zod2.z.union([SymbolState, import_zod2.z.object({ contains: import_zod2.z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: import_zod2.z.tuple([SymbolField, OrderDirection]).optional()
+});
+var SymbolRelationOptions = import_zod2.z.object({
+  select: import_zod2.z.array(SymbolField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional(),
+  deep: import_zod2.z.boolean().optional()
+});
+var DirectoryField = import_zod2.z.enum(["id", "parent_id", "path", "description", "state", "error"]);
+var DirectoryState = import_zod2.z.enum(["to_describe", "ready"]);
+var DirectorySearchOptions = import_zod2.z.object({
+  select: import_zod2.z.array(DirectoryField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional(),
+  where: import_zod2.z.object({
+    id: import_zod2.z.number().optional(),
+    parent_id: import_zod2.z.number().optional(),
+    path: StringFilter.optional(),
+    description: StringFilter.optional(),
+    state: import_zod2.z.union([DirectoryState, import_zod2.z.object({ contains: import_zod2.z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: import_zod2.z.tuple([DirectoryField, OrderDirection]).optional()
+});
+var DirectoryRelationOptions = import_zod2.z.object({
+  select: import_zod2.z.array(DirectoryField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional(),
+  deep: import_zod2.z.boolean().optional()
+});
+var DependencyField = import_zod2.z.enum(["id", "package", "subpath", "name", "version", "github_repo", "is_builtin", "description", "state", "error"]);
+var DependencyState = import_zod2.z.enum(["to_describe", "ready"]);
+var DependencySearchOptions = import_zod2.z.object({
+  select: import_zod2.z.array(DependencyField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional(),
+  where: import_zod2.z.object({
+    id: import_zod2.z.number().optional(),
+    package: StringFilter.optional(),
+    subpath: StringFilter.optional(),
+    name: StringFilter.optional(),
+    version: StringFilter.optional(),
+    github_repo: StringFilter.optional(),
+    is_builtin: import_zod2.z.boolean().optional(),
+    description: StringFilter.optional(),
+    state: import_zod2.z.union([DependencyState, import_zod2.z.object({ contains: import_zod2.z.string() })]).optional(),
+    error: StringFilter.optional()
+  }).optional(),
+  order_by: import_zod2.z.tuple([DependencyField, OrderDirection]).optional()
+});
+var DependencySelectOptions = import_zod2.z.object({
+  select: import_zod2.z.array(DependencyField).optional(),
+  limit: import_zod2.z.number().int().positive().optional(),
+  offset: import_zod2.z.number().int().nonnegative().optional()
+});
+
+// src/cli/commands/files/search.ts
 var search13 = new import_commander5.Command("search");
 search13.description("Search files with JSON options");
 search13.argument("<options>", "JSON options for search");
-search13.action(async (options_json) => {
-  const wiki = await load_wiki();
+search13.action(async (...args) => {
+  const [options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const options = parse_options(options_json, FileSearchOptions, "files search");
   const results = wiki.files.search(options);
   env.log(JSON.stringify(results, null, 2));
@@ -3024,8 +3027,9 @@ var set_description5 = new import_commander6.Command("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();
+set_description5.action(async (...args) => {
+  const [id, file] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   try {
     const content = (0, import_node_fs3.readFileSync)(file, "utf-8");
     wiki.files.set_description(Number(id), content);
@@ -3042,8 +3046,9 @@ var imported_by_file2 = new import_commander7.Command("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();
+imported_by_file2.action(async (...args) => {
+  const [file_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3055,8 +3060,9 @@ var importing_file2 = new import_commander8.Command("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();
+importing_file2.action(async (...args) => {
+  const [file_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3068,8 +3074,9 @@ var importing_dependency2 = new import_commander9.Command("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();
+importing_dependency2.action(async (...args) => {
+  const [dep_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3122,8 +3129,9 @@ var import_commander11 = require("commander");
 var get7 = new import_commander11.Command("get");
 get7.description("Get a symbol by ID");
 get7.argument("<id>", "Symbol ID");
-get7.action(async (id) => {
-  const wiki = await load_wiki();
+get7.action(async (...args) => {
+  const [id] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const symbol = wiki.symbols.get(Number(id));
   env.log(JSON.stringify(symbol, null, 2));
 });
@@ -3133,8 +3141,9 @@ var import_commander12 = require("commander");
 var search14 = new import_commander12.Command("search");
 search14.description("Search symbols with JSON options");
 search14.argument("<options>", "JSON options");
-search14.action(async (options_json) => {
-  const wiki = await load_wiki();
+search14.action(async (...args) => {
+  const [options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const options = parse_options(options_json, SymbolSearchOptions, "symbols search");
   const results = wiki.symbols.search(options);
   env.log(JSON.stringify(results, null, 2));
@@ -3147,8 +3156,9 @@ var set_description6 = new import_commander13.Command("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();
+set_description6.action(async (...args) => {
+  const [id, file] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   try {
     const content = (0, import_node_fs4.readFileSync)(file, "utf-8");
     wiki.symbols.set_description(Number(id), content);
@@ -3165,8 +3175,9 @@ var referencing_symbol2 = new import_commander14.Command("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();
+referencing_symbol2.action(async (...args) => {
+  const [symbol_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3178,8 +3189,9 @@ var referenced_by_symbol2 = new import_commander15.Command("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();
+referenced_by_symbol2.action(async (...args) => {
+  const [symbol_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3191,8 +3203,9 @@ var using_dependency4 = new import_commander16.Command("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();
+using_dependency4.action(async (...args) => {
+  const [dep_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3245,8 +3258,9 @@ var import_commander18 = require("commander");
 var get8 = new import_commander18.Command("get");
 get8.description("Get a directory by ID");
 get8.argument("<id>", "Directory ID");
-get8.action(async (id) => {
-  const wiki = await load_wiki();
+get8.action(async (...args) => {
+  const [id] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const directory = wiki.directories.get(Number(id));
   env.log(JSON.stringify(directory, null, 2));
 });
@@ -3256,8 +3270,9 @@ var import_commander19 = require("commander");
 var search15 = new import_commander19.Command("search");
 search15.description("Search directories with JSON options");
 search15.argument("<options>", "JSON options");
-search15.action(async (options_json) => {
-  const wiki = await load_wiki();
+search15.action(async (...args) => {
+  const [options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const options = parse_options(options_json, DirectorySearchOptions, "directories search");
   const results = wiki.directories.search(options);
   env.log(JSON.stringify(results, null, 2));
@@ -3270,8 +3285,9 @@ var set_description7 = new import_commander20.Command("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();
+set_description7.action(async (...args) => {
+  const [id, file] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   try {
     const content = (0, import_node_fs5.readFileSync)(file, "utf-8");
     wiki.directories.set_description(Number(id), content);
@@ -3288,8 +3304,9 @@ var children2 = new import_commander21.Command("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();
+children2.action(async (...args) => {
+  const [parent_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3301,8 +3318,9 @@ var files4 = new import_commander22.Command("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();
+files4.action(async (...args) => {
+  const [directory_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3354,8 +3372,9 @@ var import_commander24 = require("commander");
 var get9 = new import_commander24.Command("get");
 get9.description("Get a dependency by ID");
 get9.argument("<id>", "Dependency ID");
-get9.action(async (id) => {
-  const wiki = await load_wiki();
+get9.action(async (...args) => {
+  const [id] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const dependency = wiki.dependencies.get(Number(id));
   env.log(JSON.stringify(dependency, null, 2));
 });
@@ -3365,8 +3384,9 @@ var import_commander25 = require("commander");
 var search16 = new import_commander25.Command("search");
 search16.description("Search dependencies with JSON options");
 search16.argument("<options>", "JSON options");
-search16.action(async (options_json) => {
-  const wiki = await load_wiki();
+search16.action(async (...args) => {
+  const [options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   const options = parse_options(options_json, DependencySearchOptions, "dependencies search");
   const results = wiki.dependencies.search(options);
   env.log(JSON.stringify(results, null, 2));
@@ -3379,8 +3399,9 @@ var set_description8 = new import_commander26.Command("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();
+set_description8.action(async (...args) => {
+  const [id, file] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   try {
     const content = (0, import_node_fs6.readFileSync)(file, "utf-8");
     wiki.dependencies.set_description(Number(id), content);
@@ -3397,8 +3418,9 @@ var used_by_file3 = new import_commander27.Command("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();
+used_by_file3.action(async (...args) => {
+  const [file_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3410,8 +3432,9 @@ var used_by_symbol3 = new import_commander28.Command("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();
+used_by_symbol3.action(async (...args) => {
+  const [symbol_id, options_json] = args;
+  const wiki = await load_wiki(get_db_path(...args));
   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));
@@ -3460,6 +3483,7 @@ var commands = [update7, status, describe, files3, symbols3, directories3, depen
 async function run(argv) {
   const program = new import_commander30.Command();
   program.name("codewiki").description("Describe and explore TypeScript codebases").version("0.0.1");
+  program.option("--db <path>", "Database location", "./wiki.db");
   for (const cmd of commands) program.addCommand(cmd);
   return program.parseAsync(argv, { from: "user" });
 }