@staff0rd/assist 0.112.0 → 0.113.0

package/README.md

@@ -114,6 +114,13 @@ After installation, the `assist` command will be available globally. You can als
 - `assist netframework in-sln <csproj>` - Check whether a .csproj is referenced by any .sln file
 - `assist jira auth` - Authenticate with Jira via API token (saves site/email to ~/.assist/jira.json)
 - `assist jira ac <issue-key>` - Print acceptance criteria for a Jira issue
+- `assist ravendb auth` - Configure a named RavenDB connection (prompts for name, URL, database, op:// secret reference)
+- `assist ravendb auth --list` - List configured RavenDB connections
+- `assist ravendb auth --remove <name>` - Remove a configured connection
+- `assist ravendb set-connection <name>` - Set the default connection for query/collections commands
+- `assist ravendb query [connection] [collection]` - Query a RavenDB collection (outputs JSON to stdout)
+- `assist ravendb query [connection] [collection] --page-size <n> --sort <field> --query <lucene> --limit <n>` - Query with options
+- `assist ravendb collections [connection]` - List collections and document counts in a database
 - `assist complexity <pattern>` - Analyze a file (all metrics if single match, maintainability if multiple)
 - `assist complexity cyclomatic [pattern]` - Calculate cyclomatic complexity per function
 - `assist complexity halstead [pattern]` - Calculate Halstead metrics per function

package/claude/settings.json

@@ -40,6 +40,9 @@
 			"Bash(assist jira auth:*)",
 			"Bash(assist jira ac:*)",
 			"Bash(assist netframework:*)",
+			"Bash(assist ravendb query:*)",
+			"Bash(assist ravendb collections:*)",
+			"Bash(assist ravendb auth --list:*)",
 			"Bash(head:*)",
 			"Bash(tail:*)",
 			"Bash(grep:*)",

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.112.0",
+  version: "0.113.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -162,6 +162,17 @@ var assistConfigSchema = z.strictObject({
   news: z.strictObject({
     feeds: z.array(z.string()).default([])
   }).default({ feeds: [] }),
+  ravendb: z.strictObject({
+    connections: z.array(
+      z.strictObject({
+        name: z.string(),
+        url: z.string(),
+        database: z.string(),
+        apiKeyRef: z.string()
+      })
+    ).default([]),
+    defaultConnection: z.string().optional()
+  }).optional(),
   voice: z.strictObject({
     wakeWords: z.array(z.string()).default(DEFAULT_WAKE_WORDS),
     mic: z.string().optional(),
@@ -4543,13 +4554,13 @@ function saveJson(filename, data) {
 // src/commands/jira/jiraAuth.ts
 var CONFIG_FILE = "jira.json";
 async function promptCredentials(config) {
-  const { Input, Password } = Enquirer;
-  const site = await new Input({
+  const { Input: Input2, Password } = Enquirer;
+  const site = await new Input2({
     name: "site",
     message: "Jira site (e.g., mycompany.atlassian.net):",
     initial: config.site
   }).run();
-  const email = await new Input({
+  const email = await new Input2({
     name: "email",
     message: "Email:",
     initial: config.email
@@ -5631,12 +5642,420 @@ function registerPrs(program2) {
   });
 }
 
+// src/commands/ravendb/ravendbAuth.ts
+import chalk60 from "chalk";
+
+// src/commands/ravendb/loadConnections.ts
+function loadConnections() {
+  const raw = loadGlobalConfigRaw();
+  const ravendb = raw.ravendb;
+  return ravendb?.connections ?? [];
+}
+function saveConnections(connections) {
+  const raw = loadGlobalConfigRaw();
+  const ravendb = raw.ravendb ?? {};
+  ravendb.connections = connections;
+  raw.ravendb = ravendb;
+  saveGlobalConfig(raw);
+}
+
+// src/commands/ravendb/promptConnection.ts
+import chalk58 from "chalk";
+import Enquirer3 from "enquirer";
+
+// src/commands/ravendb/selectOpSecret.ts
+import chalk57 from "chalk";
+import Enquirer2 from "enquirer";
+
+// src/commands/ravendb/searchItems.ts
+import { execSync as execSync29 } from "child_process";
+import chalk56 from "chalk";
+function opExec(args) {
+  return execSync29(`op ${args}`, {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }).trim();
+}
+function searchItems(search) {
+  let items;
+  try {
+    items = JSON.parse(opExec("item list --format=json"));
+  } catch {
+    console.error(
+      chalk56.red(
+        "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
+      )
+    );
+    process.exit(1);
+  }
+  const lower = search.toLowerCase();
+  return items.filter((i) => i.title.toLowerCase().includes(lower));
+}
+function getItemFields(itemId) {
+  try {
+    const item = JSON.parse(opExec(`item get "${itemId}" --format=json`));
+    return item.fields.filter((f) => f.reference && f.label);
+  } catch {
+    console.error(chalk56.red("Failed to get item details from 1Password."));
+    process.exit(1);
+  }
+}
+
+// src/commands/ravendb/selectOpSecret.ts
+var { Input, Select } = Enquirer2;
+async function selectOne(message, choices) {
+  if (choices.length === 1) return choices[0].value;
+  const selected = await new Select({ name: "choice", message, choices }).run();
+  return choices.find((c) => c.name === selected)?.value ?? selected;
+}
+async function selectOpSecret(searchTerm) {
+  const search = searchTerm ?? await new Input({
+    name: "search",
+    message: "Search 1Password for API key item:"
+  }).run();
+  const items = searchItems(search);
+  if (items.length === 0) {
+    console.error(chalk57.red(`No items found matching "${search}".`));
+    process.exit(1);
+  }
+  const itemId = await selectOne(
+    "Select item:",
+    items.map((i) => ({ name: `${i.title} (${i.vault.name})`, value: i.id }))
+  );
+  const fields = getItemFields(itemId);
+  if (fields.length === 0) {
+    console.error(chalk57.red("No fields with references found on this item."));
+    process.exit(1);
+  }
+  const ref = await selectOne(
+    "Select field:",
+    fields.map((f) => ({ name: f.label, value: f.reference }))
+  );
+  return ref;
+}
+
+// src/commands/ravendb/promptConnection.ts
+async function promptConnection(existingNames) {
+  const { Input: Input2 } = Enquirer3;
+  const name = await new Input2({
+    name: "name",
+    message: "Connection name:"
+  }).run();
+  if (existingNames.includes(name)) {
+    console.error(chalk58.red(`Connection "${name}" already exists.`));
+    process.exit(1);
+  }
+  const url = await new Input2({
+    name: "url",
+    message: "RavenDB base URL (e.g. https://host.ravenhq.com):"
+  }).run();
+  const database = await new Input2({
+    name: "database",
+    message: "Database name:"
+  }).run();
+  if (!name || !url || !database) {
+    console.error(chalk58.red("All fields are required."));
+    process.exit(1);
+  }
+  const apiKeyRef = await selectOpSecret();
+  console.log(chalk58.dim(`Using: ${apiKeyRef}`));
+  return { name, url, database, apiKeyRef };
+}
+
+// src/commands/ravendb/ravendbSetConnection.ts
+import chalk59 from "chalk";
+function ravendbSetConnection(name) {
+  const raw = loadGlobalConfigRaw();
+  const ravendb = raw.ravendb ?? {};
+  const connections = ravendb.connections ?? [];
+  if (!connections.some((c) => c.name === name)) {
+    console.error(chalk59.red(`Connection "${name}" not found.`));
+    console.error(
+      `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
+    );
+    process.exit(1);
+  }
+  ravendb.defaultConnection = name;
+  raw.ravendb = ravendb;
+  saveGlobalConfig(raw);
+  console.log(`Default connection set to "${name}".`);
+}
+
+// src/commands/ravendb/ravendbAuth.ts
+async function ravendbAuth(options2) {
+  const connections = loadConnections();
+  if (options2.list) {
+    if (connections.length === 0) {
+      console.log("No RavenDB connections configured.");
+      return;
+    }
+    for (const c of connections) {
+      console.log(
+        `${chalk60.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`
+      );
+    }
+    return;
+  }
+  if (options2.remove) {
+    const filtered = connections.filter((c) => c.name !== options2.remove);
+    if (filtered.length === connections.length) {
+      console.error(chalk60.red(`Connection "${options2.remove}" not found.`));
+      process.exit(1);
+    }
+    saveConnections(filtered);
+    console.log(`Removed connection "${options2.remove}".`);
+    return;
+  }
+  const isFirst = connections.length === 0;
+  const newConnection = await promptConnection(connections.map((c) => c.name));
+  connections.push(newConnection);
+  saveConnections(connections);
+  if (isFirst) {
+    ravendbSetConnection(newConnection.name);
+  }
+  console.log(`Connection "${newConnection.name}" saved.`);
+}
+
+// src/commands/ravendb/ravendbCollections.ts
+import chalk64 from "chalk";
+
+// src/commands/ravendb/ravenFetch.ts
+import chalk62 from "chalk";
+
+// src/commands/ravendb/getAccessToken.ts
+var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
+var TOKEN_CACHE_MS = 50 * 60 * 1e3;
+var tokenCache = /* @__PURE__ */ new Map();
+function clearCachedToken(apiKey) {
+  tokenCache.delete(apiKey);
+}
+async function getAccessToken(apiKey) {
+  const now = Date.now();
+  const cached2 = tokenCache.get(apiKey);
+  if (cached2 && now < cached2.expiry) {
+    return cached2.token;
+  }
+  const response = await fetch(OAUTH_URL, {
+    method: "GET",
+    headers: {
+      "Api-Key": apiKey,
+      grant_type: "client_credentials"
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to get access token: ${response.status} ${response.statusText}
+${errorText}`
+    );
+  }
+  const tokenData = await response.json();
+  const token = JSON.stringify(tokenData);
+  tokenCache.set(apiKey, { token, expiry: now + TOKEN_CACHE_MS });
+  return token;
+}
+
+// src/commands/ravendb/resolveOpSecret.ts
+import { execSync as execSync30 } from "child_process";
+import chalk61 from "chalk";
+function resolveOpSecret(reference) {
+  if (!reference.startsWith("op://")) {
+    console.error(chalk61.red(`Invalid secret reference: must start with op://`));
+    process.exit(1);
+  }
+  try {
+    return execSync30(`op read "${reference}"`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    console.error(
+      chalk61.red(
+        "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
+      )
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/ravendb/ravenFetch.ts
+async function ravenFetch(connection, path42) {
+  const apiKey = resolveOpSecret(connection.apiKeyRef);
+  let accessToken = await getAccessToken(apiKey);
+  const url = `${connection.url}${path42}`;
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json"
+  };
+  let response = await fetch(url, { headers });
+  if (response.status === 401) {
+    clearCachedToken(apiKey);
+    accessToken = await getAccessToken(apiKey);
+    headers.Authorization = `Bearer ${accessToken}`;
+    response = await fetch(url, { headers });
+  }
+  if (!response.ok) {
+    const body = await response.text();
+    console.error(
+      chalk62.red(`RavenDB error: ${response.status} ${response.statusText}`)
+    );
+    console.error(body.substring(0, 500));
+    process.exit(1);
+  }
+  return response.json();
+}
+
+// src/commands/ravendb/resolveConnection.ts
+import chalk63 from "chalk";
+function loadRavendb() {
+  const raw = loadGlobalConfigRaw();
+  const ravendb = raw.ravendb;
+  return {
+    connections: ravendb?.connections ?? [],
+    defaultConnection: ravendb?.defaultConnection
+  };
+}
+function resolveConnection(name) {
+  const { connections, defaultConnection } = loadRavendb();
+  const connectionName = name ?? defaultConnection;
+  if (!connectionName) {
+    console.error(
+      chalk63.red(
+        "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
+      )
+    );
+    process.exit(1);
+  }
+  const connection = connections.find((c) => c.name === connectionName);
+  if (!connection) {
+    console.error(chalk63.red(`Connection "${connectionName}" not found.`));
+    console.error(
+      `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
+    );
+    console.error("Run assist ravendb auth to add a connection.");
+    process.exit(1);
+  }
+  return connection;
+}
+function resolveArgs(first, second) {
+  const { connections } = loadRavendb();
+  const isConnection = first && connections.some((c) => c.name === first);
+  if (isConnection) {
+    return { connection: resolveConnection(first), collection: second };
+  }
+  return { connection: resolveConnection(void 0), collection: first };
+}
+
+// src/commands/ravendb/ravendbCollections.ts
+async function ravendbCollections(connectionName) {
+  const connection = resolveConnection(connectionName);
+  const data = await ravenFetch(
+    connection,
+    `/databases/${encodeURIComponent(connection.database)}/collections/stats`
+  );
+  const collections = data.Collections ?? [];
+  if (collections.length === 0) {
+    console.log("No collections found.");
+    return;
+  }
+  for (const c of collections) {
+    console.log(`${chalk64.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+  }
+}
+
+// src/commands/ravendb/ravendbQuery.ts
+import chalk66 from "chalk";
+
+// src/commands/ravendb/fetchAllPages.ts
+import chalk65 from "chalk";
+
+// src/commands/ravendb/buildQueryPath.ts
+function buildQueryPath(opts) {
+  const db = encodeURIComponent(opts.db);
+  let path42;
+  if (opts.collection) {
+    path42 = `/databases/${db}/indexes/dynamic/${encodeURIComponent(opts.collection)}?start=${opts.start}&pageSize=${opts.pageSize}&sort=${encodeURIComponent(opts.sort)}`;
+  } else {
+    path42 = `/databases/${db}/queries?start=${opts.start}&pageSize=${opts.pageSize}`;
+  }
+  if (opts.query) {
+    path42 += `&query=${encodeURIComponent(opts.query)}`;
+  }
+  return path42;
+}
+
+// src/commands/ravendb/fetchAllPages.ts
+async function fetchAllPages(connection, opts) {
+  const allResults = [];
+  let start3 = 0;
+  while (true) {
+    const effectivePageSize = opts.limit !== void 0 ? Math.min(opts.pageSize, opts.limit - allResults.length) : opts.pageSize;
+    const path42 = buildQueryPath({
+      db: connection.database,
+      collection: opts.collection,
+      start: start3,
+      pageSize: effectivePageSize,
+      sort: opts.sort,
+      query: opts.query
+    });
+    const data = await ravenFetch(connection, path42);
+    const results = data.Results ?? [];
+    const totalResults = data.TotalResults ?? 0;
+    if (results.length === 0) break;
+    allResults.push(...results);
+    start3 += results.length;
+    process.stderr.write(
+      `\r${chalk65.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+    );
+    if (start3 >= totalResults) break;
+    if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
+  }
+  if (allResults.length > 0) {
+    process.stderr.write("\n");
+  }
+  return allResults;
+}
+
+// src/commands/ravendb/ravendbQuery.ts
+async function ravendbQuery(connectionName, collection, options2) {
+  const resolved = resolveArgs(connectionName, collection);
+  if (!resolved.collection && !options2.query) {
+    console.error(chalk66.red("Provide a collection name or --query filter."));
+    process.exit(1);
+  }
+  const { collection: col } = resolved;
+  const connection = resolved.connection;
+  const allResults = await fetchAllPages(connection, {
+    collection: col,
+    pageSize: Number.parseInt(options2.pageSize ?? "25", 10),
+    sort: options2.sort ?? "-@metadata.Last-Modified",
+    query: options2.query,
+    limit: options2.limit ? Number.parseInt(options2.limit, 10) : void 0
+  });
+  console.log(JSON.stringify(allResults, null, 2));
+}
+
+// src/commands/registerRavendb.ts
+function registerRavendb(program2) {
+  const cmd = program2.command("ravendb").description("RavenDB query utilities");
+  cmd.command("auth").description("Configure a named RavenDB connection").option("--list", "List configured connections").option("--remove <name>", "Remove a configured connection").action((options2) => ravendbAuth(options2));
+  cmd.command("set-connection <name>").description("Set the default connection").action((name) => ravendbSetConnection(name));
+  cmd.command("query [connection] [collection]").description("Query a RavenDB collection").option("--page-size <n>", "Documents per page", "25").option(
+    "--sort <field>",
+    "Sort field (prefix - for descending)",
+    "-@metadata.Last-Modified"
+  ).option("--query <lucene>", "Lucene filter query").option("--limit <n>", "Max total documents to fetch").action(
+    (connection, collection, options2) => ravendbQuery(connection, collection, options2)
+  );
+  cmd.command("collections [connection]").description("List collections in a RavenDB database").action((connection) => ravendbCollections(connection));
+}
+
 // src/commands/refactor/check/index.ts
 import { spawn as spawn3 } from "child_process";
 import * as path25 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk56 from "chalk";
+import chalk67 from "chalk";
 var DEFAULT_MAX_LINES = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
   if (violations.length === 0) {
@@ -5645,43 +6064,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES) {
     }
     return;
   }
-  console.error(chalk56.red(`
+  console.error(chalk67.red(`
 Refactor check failed:
 `));
-  console.error(chalk56.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk67.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk56.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk67.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk56.yellow(
+    chalk67.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk56.gray(`    assist refactor ignore <file>
+  console.error(chalk67.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk56.cyan(`
+    console.error(chalk67.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk56.cyan(
+      chalk67.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk56.cyan(
+      chalk67.cyan(
         `  1. Keep related logic together: If the extracted code is tightly coupled to the
      original file's domain, create a new folder containing both the original and extracted files.
 `
       )
     );
     console.error(
-      chalk56.cyan(
+      chalk67.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -5691,7 +6110,7 @@ Refactor check failed:
 }
 
 // src/commands/refactor/check/getViolations/index.ts
-import { execSync as execSync29 } from "child_process";
+import { execSync as execSync31 } from "child_process";
 import fs16 from "fs";
 import { minimatch as minimatch4 } from "minimatch";
 
@@ -5741,7 +6160,7 @@ function getGitFiles(options2) {
   }
   const files = /* @__PURE__ */ new Set();
   if (options2.staged || options2.modified) {
-    const staged = execSync29("git diff --cached --name-only", {
+    const staged = execSync31("git diff --cached --name-only", {
       encoding: "utf-8"
     });
     for (const file of staged.trim().split("\n").filter(Boolean)) {
@@ -5749,7 +6168,7 @@ function getGitFiles(options2) {
     }
   }
   if (options2.unstaged || options2.modified) {
-    const unstaged = execSync29("git diff --name-only", { encoding: "utf-8" });
+    const unstaged = execSync31("git diff --name-only", { encoding: "utf-8" });
     for (const file of unstaged.trim().split("\n").filter(Boolean)) {
       files.add(file);
     }
@@ -5837,11 +6256,11 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/ignore.ts
 import fs17 from "fs";
-import chalk57 from "chalk";
+import chalk68 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore(file) {
   if (!fs17.existsSync(file)) {
-    console.error(chalk57.red(`Error: File does not exist: ${file}`));
+    console.error(chalk68.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs17.readFileSync(file, "utf-8");
@@ -5857,7 +6276,7 @@ function ignore(file) {
     fs17.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk57.green(
+    chalk68.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -5865,7 +6284,7 @@ function ignore(file) {
 
 // src/commands/refactor/rename/index.ts
 import path26 from "path";
-import chalk58 from "chalk";
+import chalk69 from "chalk";
 import { Project as Project2 } from "ts-morph";
 async function rename(source, destination, options2 = {}) {
   const sourcePath = path26.resolve(source);
@@ -5878,22 +6297,22 @@ async function rename(source, destination, options2 = {}) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk58.red(`File not found in project: ${source}`));
+    console.log(chalk69.red(`File not found in project: ${source}`));
     process.exit(1);
   }
-  console.log(chalk58.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk69.bold(`Rename: ${relSource} \u2192 ${relDest}`));
   if (options2.apply) {
     sourceFile.move(destPath);
     await project.save();
-    console.log(chalk58.green("Done"));
+    console.log(chalk69.green("Done"));
   } else {
-    console.log(chalk58.dim("Dry run. Use --apply to execute."));
+    console.log(chalk69.dim("Dry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/renameSymbol/index.ts
 import path28 from "path";
-import chalk59 from "chalk";
+import chalk70 from "chalk";
 import { Project as Project3 } from "ts-morph";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
@@ -5942,38 +6361,38 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const project = new Project3({ tsConfigFilePath: tsConfigPath });
   const sourceFile = project.getSourceFile(filePath);
   if (!sourceFile) {
-    console.log(chalk59.red(`File not found in project: ${file}`));
+    console.log(chalk70.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk59.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk70.red(`Symbol "${oldName}" not found in ${file}`));
     process.exit(1);
   }
   const grouped = groupReferences(symbol, cwd);
   const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
   console.log(
-    chalk59.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk70.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines] of grouped) {
     console.log(
-      `  ${chalk59.dim(refFile)}: lines ${chalk59.cyan(lines.join(", "))}`
+      `  ${chalk70.dim(refFile)}: lines ${chalk70.cyan(lines.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk59.green(`
+    console.log(chalk70.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk59.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk70.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path37 from "path";
-import chalk62 from "chalk";
+import chalk73 from "chalk";
 
 // src/commands/refactor/restructure/buildImportGraph/index.ts
 import path29 from "path";
@@ -6216,50 +6635,50 @@ function computeRewrites(moves, edges, allProjectFiles) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path33 from "path";
-import chalk60 from "chalk";
+import chalk71 from "chalk";
 function relPath(filePath) {
   return path33.relative(process.cwd(), filePath);
 }
 function displayMoves(plan) {
   if (plan.moves.length === 0) return;
-  console.log(chalk60.bold("\nFile moves:"));
+  console.log(chalk71.bold("\nFile moves:"));
   for (const move of plan.moves) {
     console.log(
-      `  ${chalk60.red(relPath(move.from))} \u2192 ${chalk60.green(relPath(move.to))}`
+      `  ${chalk71.red(relPath(move.from))} \u2192 ${chalk71.green(relPath(move.to))}`
     );
-    console.log(chalk60.dim(`    ${move.reason}`));
+    console.log(chalk71.dim(`    ${move.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk60.bold(`
+  console.log(chalk71.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk60.cyan(relPath(file))}:`);
+    console.log(`  ${chalk71.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk60.red(`"${oldSpecifier}"`)} \u2192 ${chalk60.green(`"${newSpecifier}"`)}`
+        `    ${chalk71.red(`"${oldSpecifier}"`)} \u2192 ${chalk71.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan(plan) {
   if (plan.warnings.length > 0) {
-    console.log(chalk60.yellow("\nWarnings:"));
-    for (const w of plan.warnings) console.log(chalk60.yellow(`  ${w}`));
+    console.log(chalk71.yellow("\nWarnings:"));
+    for (const w of plan.warnings) console.log(chalk71.yellow(`  ${w}`));
   }
   if (plan.newDirectories.length > 0) {
-    console.log(chalk60.bold("\nNew directories:"));
+    console.log(chalk71.bold("\nNew directories:"));
     for (const dir of plan.newDirectories)
-      console.log(chalk60.green(`  ${dir}/`));
+      console.log(chalk71.green(`  ${dir}/`));
   }
   displayMoves(plan);
   displayRewrites(plan.rewrites);
   console.log(
-    chalk60.dim(
+    chalk71.dim(
       `
 Summary: ${plan.moves.length} file(s) moved, ${plan.rewrites.length} imports rewritten`
     )
@@ -6269,18 +6688,18 @@ Summary: ${plan.moves.length} file(s) moved, ${plan.rewrites.length} imports rew
 // src/commands/refactor/restructure/executePlan.ts
 import fs19 from "fs";
 import path34 from "path";
-import chalk61 from "chalk";
+import chalk72 from "chalk";
 function executePlan(plan) {
   const updatedContents = applyRewrites(plan.rewrites);
   for (const [file, content] of updatedContents) {
     fs19.writeFileSync(file, content, "utf-8");
     console.log(
-      chalk61.cyan(`  Rewrote imports in ${path34.relative(process.cwd(), file)}`)
+      chalk72.cyan(`  Rewrote imports in ${path34.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan.newDirectories) {
     fs19.mkdirSync(dir, { recursive: true });
-    console.log(chalk61.green(`  Created ${path34.relative(process.cwd(), dir)}/`));
+    console.log(chalk72.green(`  Created ${path34.relative(process.cwd(), dir)}/`));
   }
   for (const move of plan.moves) {
     const targetDir = path34.dirname(move.to);
@@ -6289,7 +6708,7 @@ function executePlan(plan) {
     }
     fs19.renameSync(move.from, move.to);
     console.log(
-      chalk61.white(
+      chalk72.white(
         `  Moved ${path34.relative(process.cwd(), move.from)} \u2192 ${path34.relative(process.cwd(), move.to)}`
       )
     );
@@ -6304,7 +6723,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs19.rmdirSync(dir);
       console.log(
-        chalk61.dim(
+        chalk72.dim(
           `  Removed empty directory ${path34.relative(process.cwd(), dir)}`
         )
       );
@@ -6437,22 +6856,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk62.yellow("No files found matching pattern"));
+    console.log(chalk73.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = path37.resolve("tsconfig.json");
   const plan = buildPlan(files, tsConfigPath);
   if (plan.moves.length === 0) {
-    console.log(chalk62.green("No restructuring needed"));
+    console.log(chalk73.green("No restructuring needed"));
     return;
   }
   displayPlan(plan);
   if (options2.apply) {
-    console.log(chalk62.bold("\nApplying changes..."));
+    console.log(chalk73.bold("\nApplying changes..."));
     executePlan(plan);
-    console.log(chalk62.green("\nRestructuring complete"));
+    console.log(chalk73.green("\nRestructuring complete"));
   } else {
-    console.log(chalk62.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk73.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -7000,14 +7419,14 @@ import {
 import { dirname as dirname18, join as join26 } from "path";
 
 // src/commands/transcript/summarise/processStagedFile/validateStagedContent.ts
-import chalk63 from "chalk";
+import chalk74 from "chalk";
 var FULL_TRANSCRIPT_REGEX = /^\[Full Transcript\]\(([^)]+)\)/;
 function validateStagedContent(filename, content) {
   const firstLine = content.split("\n")[0];
   const match = firstLine.match(FULL_TRANSCRIPT_REGEX);
   if (!match) {
     console.error(
-      chalk63.red(
+      chalk74.red(
         `Staged file ${filename} missing [Full Transcript](<path>) link on first line.`
       )
     );
@@ -7016,7 +7435,7 @@ function validateStagedContent(filename, content) {
   const contentAfterLink = content.slice(firstLine.length).trim();
   if (!contentAfterLink) {
     console.error(
-      chalk63.red(
+      chalk74.red(
         `Staged file ${filename} has no summary content after the transcript link.`
       )
     );
@@ -7216,7 +7635,7 @@ import { mkdirSync as mkdirSync10 } from "fs";
 import { join as join31 } from "path";
 
 // src/commands/voice/checkLockFile.ts
-import { execSync as execSync30 } from "child_process";
+import { execSync as execSync32 } from "child_process";
 import { existsSync as existsSync31, mkdirSync as mkdirSync9, readFileSync as readFileSync25, writeFileSync as writeFileSync23 } from "fs";
 import { join as join30 } from "path";
 function isProcessAlive(pid) {
@@ -7245,7 +7664,7 @@ function bootstrapVenv() {
   if (existsSync31(getVenvPython())) return;
   console.log("Setting up Python environment...");
   const pythonDir = getPythonDir();
-  execSync30(
+  execSync32(
     `uv sync --project "${pythonDir}" --extra runtime --no-install-project`,
     {
       stdio: "inherit",
@@ -7409,14 +7828,14 @@ function registerVoice(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk64 from "chalk";
+import chalk75 from "chalk";
 
 // src/lib/openBrowser.ts
-import { execSync as execSync31 } from "child_process";
+import { execSync as execSync33 } from "child_process";
 function tryExec(commands) {
   for (const cmd of commands) {
     try {
-      execSync31(cmd);
+      execSync33(cmd);
       return true;
     } catch {
     }
@@ -7584,13 +8003,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk64.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk75.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk64.white("http://localhost:14523/callback\n"));
-  console.log(chalk64.blue("Opening browser for authorization..."));
-  console.log(chalk64.dim("Waiting for authorization callback..."));
+  console.log(chalk75.white("http://localhost:14523/callback\n"));
+  console.log(chalk75.blue("Opening browser for authorization..."));
+  console.log(chalk75.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk64.dim("Exchanging code for tokens..."));
+  console.log(chalk75.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -7606,7 +8025,7 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk64.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk75.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
@@ -7794,14 +8213,14 @@ function run2(name, args) {
 }
 
 // src/commands/statusLine.ts
-import chalk65 from "chalk";
+import chalk76 from "chalk";
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
 function colorizePercent(pct) {
   const label2 = `${pct}%`;
-  if (pct > 80) return chalk65.red(label2);
-  if (pct > 40) return chalk65.yellow(label2);
+  if (pct > 80) return chalk76.red(label2);
+  if (pct > 40) return chalk76.yellow(label2);
   return label2;
 }
 async function statusLine() {
@@ -7827,7 +8246,7 @@ import { fileURLToPath as fileURLToPath7 } from "url";
 // src/commands/sync/syncClaudeMd.ts
 import * as fs22 from "fs";
 import * as path38 from "path";
-import chalk66 from "chalk";
+import chalk77 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase) {
   const source = path38.join(claudeDir, "CLAUDE.md");
   const target = path38.join(targetBase, "CLAUDE.md");
@@ -7836,12 +8255,12 @@ async function syncClaudeMd(claudeDir, targetBase) {
     const targetContent = fs22.readFileSync(target, "utf-8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk66.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk77.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       const confirm = await promptConfirm(
-        chalk66.red("Overwrite existing CLAUDE.md?"),
+        chalk77.red("Overwrite existing CLAUDE.md?"),
         false
       );
       if (!confirm) {
@@ -7857,7 +8276,7 @@ async function syncClaudeMd(claudeDir, targetBase) {
 // src/commands/sync/syncSettings.ts
 import * as fs23 from "fs";
 import * as path39 from "path";
-import chalk67 from "chalk";
+import chalk78 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path39.join(claudeDir, "settings.json");
   const target = path39.join(targetBase, "settings.json");
@@ -7873,14 +8292,14 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk67.yellow(
+          chalk78.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
         console.log();
         printDiff(targetContent, mergedContent);
         const confirm = await promptConfirm(
-          chalk67.red("Overwrite existing settings.json?"),
+          chalk78.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -7917,7 +8336,7 @@ function syncCommands(claudeDir, targetBase) {
 }
 
 // src/commands/update.ts
-import { execSync as execSync32 } from "child_process";
+import { execSync as execSync34 } from "child_process";
 import * as path41 from "path";
 function isGlobalNpmInstall(dir) {
   try {
@@ -7925,7 +8344,7 @@ function isGlobalNpmInstall(dir) {
     if (resolved.split(path41.sep).includes("node_modules")) {
       return true;
     }
-    const globalPrefix = execSync32("npm prefix -g", { stdio: "pipe" }).toString().trim();
+    const globalPrefix = execSync34("npm prefix -g", { stdio: "pipe" }).toString().trim();
     return resolved.toLowerCase().startsWith(path41.resolve(globalPrefix).toLowerCase());
   } catch {
     return false;
@@ -7936,18 +8355,18 @@ async function update() {
   console.log(`Assist is installed at: ${installDir}`);
   if (isGitRepo(installDir)) {
     console.log("Detected git repo installation, pulling latest...");
-    execSync32("git pull", { cwd: installDir, stdio: "inherit" });
+    execSync34("git pull", { cwd: installDir, stdio: "inherit" });
     console.log("Installing dependencies...");
-    execSync32("npm i", { cwd: installDir, stdio: "inherit" });
+    execSync34("npm i", { cwd: installDir, stdio: "inherit" });
     console.log("Building...");
-    execSync32("npm run build", { cwd: installDir, stdio: "inherit" });
+    execSync34("npm run build", { cwd: installDir, stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync32("assist sync", { stdio: "inherit" });
+    execSync34("assist sync", { stdio: "inherit" });
   } else if (isGlobalNpmInstall(installDir)) {
     console.log("Detected global npm installation, updating...");
-    execSync32("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
+    execSync34("npm i -g @staff0rd/assist@latest", { stdio: "inherit" });
     console.log("Syncing commands...");
-    execSync32("assist sync", { stdio: "inherit" });
+    execSync34("assist sync", { stdio: "inherit" });
   } else {
     console.error(
       "Could not determine installation method. Expected a git repo or global npm install."
@@ -7996,6 +8415,7 @@ registerDeploy(program);
 registerComplexity(program);
 registerNetframework(program);
 registerNews(program);
+registerRavendb(program);
 registerTranscript(program);
 registerVoice(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.112.0",
+	"version": "0.113.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {