simplemdg-dev-cli 2.0.4 → 2.4.4

package/src/core/db/db-metadata.ts

@@ -0,0 +1,174 @@
+import type { TDatabaseColumn, TDatabaseType, TSqlSafetyAnalysis } from "./db-types";
+
+// Keywords blocked when the studio runs in read-only mode.
+const READ_ONLY_BLOCKED_KEYWORDS = [
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "DROP",
+  "TRUNCATE",
+  "ALTER",
+  "CREATE",
+  "REPLACE",
+  "GRANT",
+  "REVOKE",
+  "MERGE",
+  "UPSERT",
+];
+
+// Statements that always warrant an explicit confirmation before running.
+const DESTRUCTIVE_KEYWORDS = ["DROP", "TRUNCATE", "ALTER", "GRANT", "REVOKE"];
+
+export function quoteIdentifier(_type: TDatabaseType, identifier: string): string {
+  // Both HANA and PostgreSQL use double quotes for delimited identifiers and
+  // escape an embedded double quote by doubling it.
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+export function buildQualifiedName(type: TDatabaseType, schema: string, name: string): string {
+  if (!schema) {
+    return quoteIdentifier(type, name);
+  }
+
+  return `${quoteIdentifier(type, schema)}.${quoteIdentifier(type, name)}`;
+}
+
+export function generateSelectSql(type: TDatabaseType, schema: string, table: string, limit = 100): string {
+  return `SELECT * FROM ${buildQualifiedName(type, schema, table)} LIMIT ${limit}`;
+}
+
+export function generateCountSql(type: TDatabaseType, schema: string, table: string): string {
+  return `SELECT COUNT(*) AS ROW_COUNT FROM ${buildQualifiedName(type, schema, table)}`;
+}
+
+function formatColumnType(column: TDatabaseColumn): string {
+  const dataType = column.dataType.toUpperCase();
+
+  if (column.length && /CHAR|VARCHAR|NVARCHAR|VARBINARY|BINARY/.test(dataType)) {
+    return `${column.dataType}(${column.length})`;
+  }
+
+  if (column.scale != null && /DECIMAL|NUMERIC/.test(dataType)) {
+    return `${column.dataType}(${column.length ?? 38},${column.scale})`;
+  }
+
+  return column.dataType;
+}
+
+/**
+ * Best-effort CREATE TABLE statement reconstructed from column metadata. Useful
+ * as a starting point for editing in the SQL console.
+ */
+export function generateCreateTableDdl(
+  type: TDatabaseType,
+  schema: string,
+  table: string,
+  columns: TDatabaseColumn[],
+): string {
+  const columnLines = columns.map((column) => {
+    const nullable = column.nullable ? "" : " NOT NULL";
+    const defaultValue = column.defaultValue ? ` DEFAULT ${column.defaultValue}` : "";
+    return `  ${quoteIdentifier(type, column.name)} ${formatColumnType(column)}${nullable}${defaultValue}`;
+  });
+
+  const primaryKeyColumns = columns.filter((column) => column.isPrimaryKey).map((column) => quoteIdentifier(type, column.name));
+
+  if (primaryKeyColumns.length > 0) {
+    columnLines.push(`  PRIMARY KEY (${primaryKeyColumns.join(", ")})`);
+  }
+
+  return `CREATE TABLE ${buildQualifiedName(type, schema, table)} (\n${columnLines.join(",\n")}\n);`;
+}
+
+function stripSqlComments(sql: string): string {
+  return sql
+    .replace(/--[^\n]*/g, " ")
+    .replace(/\/\*[\s\S]*?\*\//g, " ");
+}
+
+export function getLeadingStatementKeyword(sql: string): string {
+  const cleaned = stripSqlComments(sql).trim();
+  const match = cleaned.match(/^([a-z]+)/i);
+  return match ? match[1].toUpperCase() : "";
+}
+
+export function isSingleSelectStatement(sql: string): boolean {
+  const cleaned = stripSqlComments(sql).trim().replace(/;\s*$/, "");
+  if (cleaned.includes(";")) {
+    return false;
+  }
+
+  const keyword = getLeadingStatementKeyword(cleaned);
+  return keyword === "SELECT" || keyword === "WITH";
+}
+
+/**
+ * Append a row limit to a single SELECT statement when one is not already
+ * present, so accidental full-table scans stay bounded.
+ */
+export function appendSafeLimit(_type: TDatabaseType, sql: string, limit: number): string {
+  if (limit <= 0) {
+    return sql;
+  }
+
+  if (!isSingleSelectStatement(sql)) {
+    return sql;
+  }
+
+  const cleaned = stripSqlComments(sql);
+
+  if (/\blimit\s+\d+/i.test(cleaned) || /\btop\s+\d+/i.test(cleaned) || /\bfetch\s+first\b/i.test(cleaned)) {
+    return sql;
+  }
+
+  const trimmed = sql.replace(/;\s*$/, "").trimEnd();
+  return `${trimmed} LIMIT ${limit}`;
+}
+
+export function analyzeSqlSafety(sql: string, options: { readOnly: boolean }): TSqlSafetyAnalysis {
+  const cleaned = stripSqlComments(sql).trim();
+  const upper = cleaned.toUpperCase();
+  const matchedKeywords: string[] = [];
+
+  for (const keyword of READ_ONLY_BLOCKED_KEYWORDS) {
+    if (new RegExp(`\\b${keyword}\\b`).test(upper)) {
+      matchedKeywords.push(keyword);
+    }
+  }
+
+  const hasDestructiveKeyword = DESTRUCTIVE_KEYWORDS.some((keyword) => new RegExp(`\\b${keyword}\\b`).test(upper));
+  const leadingKeyword = getLeadingStatementKeyword(cleaned);
+
+  const isDeleteWithoutWhere = leadingKeyword === "DELETE" && !/\bWHERE\b/.test(upper);
+  const isUpdateWithoutWhere = leadingKeyword === "UPDATE" && !/\bWHERE\b/.test(upper);
+
+  const isDestructive = hasDestructiveKeyword || isDeleteWithoutWhere || isUpdateWithoutWhere;
+  const isReadOnly = matchedKeywords.length === 0;
+  const blockedByReadOnly = options.readOnly && matchedKeywords.length > 0;
+
+  let reason: string | undefined;
+
+  if (isDeleteWithoutWhere) {
+    reason = "DELETE without a WHERE clause affects every row.";
+  } else if (isUpdateWithoutWhere) {
+    reason = "UPDATE without a WHERE clause affects every row.";
+  } else if (hasDestructiveKeyword) {
+    reason = `Statement contains a destructive keyword: ${matchedKeywords.filter((keyword) => DESTRUCTIVE_KEYWORDS.includes(keyword)).join(", ")}.`;
+  }
+
+  return {
+    isDestructive,
+    isReadOnly,
+    blockedByReadOnly,
+    matchedKeywords,
+    reason,
+  };
+}
+
+/**
+ * Heuristic: an org or app name that looks production-like, used to warn the
+ * developer before they connect.
+ */
+export function looksLikeProduction(...values: Array<string | undefined>): boolean {
+  return values.some((value) => value && /\b(prod|production|prd|live)\b/i.test(value));
+}

package/src/core/db/db-postgres-adapter.ts

@@ -0,0 +1,275 @@
+import type { Client as PgClient, QueryResult } from "pg";
+import { buildQualifiedName, quoteIdentifier } from "./db-metadata";
+import type {
+  IDatabaseAdapter,
+  TConnectionTestResult,
+  TDatabaseColumn,
+  TDatabaseIndex,
+  TDatabaseObject,
+  TDatabaseQueryResult,
+  TDatabaseSchema,
+  TDatabaseType,
+  TListObjectsOptions,
+  TResolvedDatabaseConnection,
+  TTableDataOptions,
+} from "./db-types";
+
+const SYSTEM_SCHEMAS = new Set(["pg_catalog", "information_schema", "pg_toast"]);
+
+type TPgRow = Record<string, unknown>;
+
+export class PostgresAdapter implements IDatabaseAdapter {
+  public readonly type: TDatabaseType = "postgresql";
+
+  private client: PgClient | undefined;
+
+  private readonly queryTimeoutMs: number;
+
+  constructor(
+    private readonly connection: TResolvedDatabaseConnection,
+    options?: { queryTimeoutMs?: number },
+  ) {
+    this.queryTimeoutMs = options?.queryTimeoutMs ?? 30000;
+  }
+
+  public async connect(): Promise<void> {
+    if (this.client) {
+      return;
+    }
+
+    let pgModule: typeof import("pg");
+
+    try {
+      pgModule = await import("pg");
+    } catch {
+      throw new Error("PostgreSQL driver 'pg' is not installed. Run: npm install pg");
+    }
+
+    const PgClientCtor = pgModule.Client ?? (pgModule as unknown as { default: typeof import("pg") }).default.Client;
+    const client = new PgClientCtor({
+      host: this.connection.host,
+      port: this.connection.port,
+      user: this.connection.username,
+      password: this.connection.password,
+      database: this.connection.database,
+      ssl: this.connection.ssl ? { rejectUnauthorized: this.connection.sslValidateCertificate ?? false } : undefined,
+      statement_timeout: this.queryTimeoutMs,
+      connectionTimeoutMillis: 15000,
+    });
+
+    await client.connect();
+    this.client = client;
+  }
+
+  public async disconnect(): Promise<void> {
+    if (this.client) {
+      await this.client.end().catch(() => undefined);
+      this.client = undefined;
+    }
+  }
+
+  private async getClient(): Promise<PgClient> {
+    if (!this.client) {
+      await this.connect();
+    }
+
+    if (!this.client) {
+      throw new Error("PostgreSQL connection is not established");
+    }
+
+    return this.client;
+  }
+
+  public async testConnection(): Promise<TConnectionTestResult> {
+    const startedAt = Date.now();
+
+    try {
+      const client = await this.getClient();
+      const result = await client.query("SELECT version() AS version");
+      const version = String((result.rows[0] as TPgRow | undefined)?.version ?? "PostgreSQL");
+      return { success: true, message: "Connection successful", serverVersion: version, durationMs: Date.now() - startedAt };
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - startedAt,
+      };
+    }
+  }
+
+  private toQueryResult(result: QueryResult, durationMs: number, maxRows?: number): TDatabaseQueryResult {
+    const fields = (result.fields ?? []).map((field) => field.name);
+    const allRows = (result.rows ?? []) as TPgRow[];
+    const limit = maxRows ?? 0;
+    const truncated = limit > 0 && allRows.length > limit;
+    const rows = truncated ? allRows.slice(0, limit) : allRows;
+    const command = result.command;
+    const isSelect = command === "SELECT" || command === "SHOW";
+
+    return {
+      fields: fields.length > 0 ? fields : rows.length > 0 ? Object.keys(rows[0]) : [],
+      rows,
+      rowCount: rows.length,
+      affectedRows: isSelect ? undefined : result.rowCount ?? undefined,
+      command,
+      durationMs,
+      truncated,
+    };
+  }
+
+  public async runQuery(sql: string, options?: { maxRows?: number }): Promise<TDatabaseQueryResult> {
+    const client = await this.getClient();
+    const startedAt = Date.now();
+    const rawResult = await client.query(sql);
+    const result = Array.isArray(rawResult) ? rawResult[rawResult.length - 1] as QueryResult : rawResult as QueryResult;
+    return this.toQueryResult(result, Date.now() - startedAt, options?.maxRows);
+  }
+
+  public async runParameterized(sql: string, params: unknown[], options?: { maxRows?: number }): Promise<TDatabaseQueryResult> {
+    const client = await this.getClient();
+    const startedAt = Date.now();
+    const result = await client.query(sql, params) as QueryResult;
+    return this.toQueryResult(result, Date.now() - startedAt, options?.maxRows);
+  }
+
+  public placeholder(index: number): string {
+    return `$${index}`;
+  }
+
+  public async listSchemas(): Promise<TDatabaseSchema[]> {
+    const client = await this.getClient();
+    const result = await client.query("SELECT schema_name FROM information_schema.schemata ORDER BY schema_name");
+    return (result.rows as TPgRow[]).map((row) => {
+      const name = String(row.schema_name);
+      return { name, isSystem: SYSTEM_SCHEMAS.has(name) || name.startsWith("pg_") };
+    });
+  }
+
+  public async listObjects(options: TListObjectsOptions): Promise<TDatabaseObject[]> {
+    const client = await this.getClient();
+    const schema = options.schema;
+    const kinds = options.kinds;
+    const objects: TDatabaseObject[] = [];
+
+    if (!schema) {
+      return objects;
+    }
+
+    const wantsTable = !kinds || kinds.includes("table");
+    const wantsView = !kinds || kinds.includes("view");
+    const wantsFunction = !kinds || kinds.includes("function") || kinds.includes("procedure");
+
+    if (wantsTable || wantsView) {
+      const tables = await client.query(
+        "SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = $1 ORDER BY table_name",
+        [schema],
+      );
+
+      for (const row of tables.rows as TPgRow[]) {
+        const isView = String(row.table_type) === "VIEW";
+        if (isView && !wantsView) continue;
+        if (!isView && !wantsTable) continue;
+        objects.push({ schema, name: String(row.table_name), kind: isView ? "view" : "table", type: String(row.table_type) });
+      }
+    }
+
+    if (wantsFunction) {
+      const routines = await client.query(
+        "SELECT routine_name, routine_type FROM information_schema.routines WHERE routine_schema = $1 ORDER BY routine_name",
+        [schema],
+      );
+
+      for (const row of routines.rows as TPgRow[]) {
+        const isProcedure = String(row.routine_type) === "PROCEDURE";
+        objects.push({ schema, name: String(row.routine_name), kind: isProcedure ? "procedure" : "function", type: String(row.routine_type) });
+      }
+    }
+
+    const search = options.search?.trim().toLowerCase();
+    return search ? objects.filter((object) => object.name.toLowerCase().includes(search)) : objects;
+  }
+
+  public async listColumns(schema: string, table: string): Promise<TDatabaseColumn[]> {
+    const client = await this.getClient();
+    const columnsResult = await client.query(
+      `SELECT c.column_name, c.data_type, c.character_maximum_length, c.numeric_precision, c.numeric_scale, c.is_nullable, c.column_default, c.ordinal_position,
+              (SELECT pgd.description
+                 FROM pg_catalog.pg_description pgd
+                 JOIN pg_catalog.pg_class cls ON cls.oid = pgd.objoid
+                 JOIN pg_catalog.pg_namespace ns ON ns.oid = cls.relnamespace
+                WHERE ns.nspname = c.table_schema AND cls.relname = c.table_name AND pgd.objsubid = c.ordinal_position) AS column_comment
+       FROM information_schema.columns c
+       WHERE c.table_schema = $1 AND c.table_name = $2
+       ORDER BY c.ordinal_position`,
+      [schema, table],
+    );
+
+    const primaryKeyResult = await client.query(
+      `SELECT kcu.column_name
+       FROM information_schema.table_constraints tc
+       JOIN information_schema.key_column_usage kcu
+         ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+       WHERE tc.constraint_type = 'PRIMARY KEY' AND tc.table_schema = $1 AND tc.table_name = $2`,
+      [schema, table],
+    );
+
+    const primaryKeyColumns = new Set((primaryKeyResult.rows as TPgRow[]).map((row) => String(row.column_name)));
+
+    return (columnsResult.rows as TPgRow[]).map((row) => ({
+      name: String(row.column_name),
+      dataType: String(row.data_type),
+      length: row.character_maximum_length === null ? undefined : Number(row.character_maximum_length),
+      scale: row.numeric_scale === null ? undefined : Number(row.numeric_scale),
+      nullable: String(row.is_nullable).toUpperCase() === "YES",
+      defaultValue: row.column_default === null ? undefined : String(row.column_default),
+      isPrimaryKey: primaryKeyColumns.has(String(row.column_name)),
+      comment: row.column_comment === null || row.column_comment === undefined ? undefined : String(row.column_comment),
+      position: Number(row.ordinal_position),
+    }));
+  }
+
+  public async listIndexes(schema: string, table: string): Promise<TDatabaseIndex[]> {
+    const client = await this.getClient();
+    const result = await client.query(
+      "SELECT indexname, indexdef FROM pg_indexes WHERE schemaname = $1 AND tablename = $2",
+      [schema, table],
+    );
+
+    return (result.rows as TPgRow[]).map((row) => {
+      const name = String(row.indexname);
+      const definition = String(row.indexdef);
+      const columnMatch = definition.match(/\(([^)]+)\)/);
+      const columns = columnMatch ? columnMatch[1].split(",").map((column) => column.trim().replace(/"/g, "")) : [];
+      return {
+        name,
+        columns,
+        isUnique: /\bUNIQUE\b/i.test(definition),
+        isPrimaryKey: name.endsWith("_pkey"),
+      };
+    });
+  }
+
+  public async countRows(schema: string, table: string): Promise<number> {
+    const client = await this.getClient();
+    const result = await client.query(`SELECT COUNT(*) AS count FROM ${buildQualifiedName(this.type, schema, table)}`);
+    return Number((result.rows[0] as TPgRow | undefined)?.count ?? 0);
+  }
+
+  public async getTableData(options: TTableDataOptions): Promise<TDatabaseQueryResult> {
+    const qualifiedName = buildQualifiedName(this.type, options.schema, options.table);
+    const whereClause = options.where?.trim() ? ` WHERE ${options.where.trim()}` : "";
+    const orderClause = options.orderBy?.trim()
+      ? ` ORDER BY ${quoteIdentifier(this.type, options.orderBy.trim())} ${options.orderDirection === "desc" ? "DESC" : "ASC"}`
+      : "";
+    const sql = `SELECT * FROM ${qualifiedName}${whereClause}${orderClause} LIMIT ${options.limit} OFFSET ${options.offset}`;
+    return this.runQuery(sql, { maxRows: options.limit });
+  }
+
+  public quoteIdentifier(identifier: string): string {
+    return quoteIdentifier(this.type, identifier);
+  }
+
+  public buildQualifiedName(schema: string, name: string): string {
+    return buildQualifiedName(this.type, schema, name);
+  }
+}

package/src/core/db/db-query-files.ts

@@ -0,0 +1,130 @@
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import fs from "fs-extra";
+import type { TDatabaseType, TSavedQuery } from "./db-types";
+
+const QUERIES_DIRECTORY = path.join(os.homedir(), ".simplemdg", "db-queries");
+
+export type TSaveQueryInput = {
+  id?: string;
+  name: string;
+  sql: string;
+  connectionType?: TDatabaseType;
+  connectionId?: string;
+  tags?: string[];
+};
+
+function queryFilePath(id: string): string {
+  return path.join(QUERIES_DIRECTORY, `${id}.json`);
+}
+
+function sanitizeFileBaseName(name: string): string {
+  return name.replace(/[^a-z0-9-_]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "query";
+}
+
+export async function listSavedQueries(): Promise<TSavedQuery[]> {
+  if (!(await fs.pathExists(QUERIES_DIRECTORY))) {
+    return [];
+  }
+
+  const entries = await fs.readdir(QUERIES_DIRECTORY);
+  const queries: TSavedQuery[] = [];
+
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) {
+      continue;
+    }
+
+    const parsed = await fs.readJson(path.join(QUERIES_DIRECTORY, entry)).catch(() => undefined) as TSavedQuery | undefined;
+
+    if (parsed?.id && typeof parsed.sql === "string") {
+      queries.push(parsed);
+    }
+  }
+
+  return queries.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+
+export async function getSavedQuery(id: string): Promise<TSavedQuery | undefined> {
+  const filePath = queryFilePath(id);
+
+  if (!(await fs.pathExists(filePath))) {
+    return undefined;
+  }
+
+  return await fs.readJson(filePath).catch(() => undefined) as TSavedQuery | undefined;
+}
+
+export async function saveQuery(input: TSaveQueryInput): Promise<TSavedQuery> {
+  await fs.ensureDir(QUERIES_DIRECTORY);
+  const now = new Date().toISOString();
+  const existing = input.id ? await getSavedQuery(input.id) : undefined;
+
+  const query: TSavedQuery = {
+    id: existing?.id ?? input.id ?? crypto.randomUUID(),
+    name: input.name.trim() || "Untitled query",
+    sql: input.sql,
+    connectionType: input.connectionType ?? existing?.connectionType,
+    connectionId: input.connectionId ?? existing?.connectionId,
+    tags: input.tags ?? existing?.tags ?? [],
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+  };
+
+  await fs.writeJson(queryFilePath(query.id), query, { spaces: 2 });
+  return query;
+}
+
+export async function renameSavedQuery(id: string, name: string): Promise<TSavedQuery> {
+  const query = await getSavedQuery(id);
+
+  if (!query) {
+    throw new Error(`Saved query not found: ${id}`);
+  }
+
+  query.name = name.trim() || query.name;
+  query.updatedAt = new Date().toISOString();
+  await fs.writeJson(queryFilePath(id), query, { spaces: 2 });
+  return query;
+}
+
+export async function deleteSavedQuery(id: string): Promise<boolean> {
+  const filePath = queryFilePath(id);
+
+  if (!(await fs.pathExists(filePath))) {
+    return false;
+  }
+
+  await fs.remove(filePath);
+  return true;
+}
+
+export async function exportSavedQueryToSql(id: string, targetDirectory: string): Promise<string> {
+  const query = await getSavedQuery(id);
+
+  if (!query) {
+    throw new Error(`Saved query not found: ${id}`);
+  }
+
+  await fs.ensureDir(targetDirectory);
+  const targetPath = path.join(targetDirectory, `${sanitizeFileBaseName(query.name)}.sql`);
+  await fs.writeFile(targetPath, query.sql, "utf8");
+  return targetPath;
+}
+
+export async function importSqlFile(filePath: string, options?: { name?: string; tags?: string[] }): Promise<TSavedQuery> {
+  const resolvedPath = path.resolve(filePath);
+
+  if (!(await fs.pathExists(resolvedPath))) {
+    throw new Error(`SQL file not found: ${resolvedPath}`);
+  }
+
+  const sql = await fs.readFile(resolvedPath, "utf8");
+  const name = options?.name?.trim() || path.basename(resolvedPath, path.extname(resolvedPath));
+  return saveQuery({ name, sql, tags: options?.tags });
+}
+
+export function getQueriesDirectory(): string {
+  return QUERIES_DIRECTORY;
+}

package/src/core/db/db-query-history.ts

@@ -0,0 +1,53 @@
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import fs from "fs-extra";
+import type { TQueryHistoryItem } from "./db-types";
+
+const CACHE_DIRECTORY = path.join(os.homedir(), ".simplemdg");
+const HISTORY_FILE_PATH = path.join(CACHE_DIRECTORY, "db-query-history.json");
+const MAX_HISTORY_ITEMS = 300;
+
+type THistoryFile = {
+  items: TQueryHistoryItem[];
+};
+
+async function readHistoryFile(): Promise<THistoryFile> {
+  if (!(await fs.pathExists(HISTORY_FILE_PATH))) {
+    return { items: [] };
+  }
+
+  const parsed = await fs.readJson(HISTORY_FILE_PATH).catch(() => ({ items: [] })) as Partial<THistoryFile>;
+  return { items: Array.isArray(parsed.items) ? parsed.items : [] };
+}
+
+async function writeHistoryFile(file: THistoryFile): Promise<void> {
+  await fs.ensureDir(CACHE_DIRECTORY);
+  await fs.writeJson(HISTORY_FILE_PATH, file, { spaces: 2 });
+}
+
+export async function appendQueryHistory(item: Omit<TQueryHistoryItem, "id" | "timestamp">): Promise<TQueryHistoryItem> {
+  const file = await readHistoryFile();
+  const entry: TQueryHistoryItem = {
+    ...item,
+    id: crypto.randomUUID(),
+    timestamp: new Date().toISOString(),
+  };
+
+  file.items = [entry, ...file.items].slice(0, MAX_HISTORY_ITEMS);
+  await writeHistoryFile(file);
+  return entry;
+}
+
+export async function listQueryHistory(limit = 100): Promise<TQueryHistoryItem[]> {
+  const file = await readHistoryFile();
+  return file.items.slice(0, limit);
+}
+
+export async function clearQueryHistory(): Promise<void> {
+  await writeHistoryFile({ items: [] });
+}
+
+export function getHistoryFilePath(): string {
+  return HISTORY_FILE_PATH;
+}