mantisai-cli 2.0.1 → 3.0.0

package/lib/container.js

@@ -0,0 +1,63 @@
+import { FileConfigStore } from './impl/file-config-store.js';
+import { HttpMantisClient } from './impl/http-mantis-client.js';
+import { McpClientService } from './impl/mcp-client-service.js';
+import { SpaceRepositoryImpl } from './impl/space-repository.js';
+import { InquirerUiService } from './impl/inquirer-ui-service.js';
+import { FastGlobCodebaseIndexer } from './impl/fast-glob-codebase-indexer.js';
+import { FsCsvReader } from './impl/fs-csv-reader.js';
+import { ClaudeSkillsService } from './impl/claude-skills-service.js';
+import { OpencodeSkillsService } from './impl/opencode-skills-service.js';
+import { SelectionService } from './services/selection-service.js';
+import { SetupService } from './services/setup-service.js';
+import { MapService } from './services/map-service.js';
+import { QueryService } from './services/query-service.js';
+import { ContextService } from './services/context-service.js';
+import { ToolService } from './services/tool-service.js';
+
+export function createContainer(overrides = {}) {
+  const configStore = overrides.configStore ?? new FileConfigStore();
+  const client = overrides.client ?? new HttpMantisClient(configStore);
+  const spaces = overrides.spaces ?? new SpaceRepositoryImpl(client);
+  const ui = overrides.ui ?? new InquirerUiService();
+  const mcp = overrides.mcp ?? new McpClientService(configStore);
+  const codebaseIndexer = overrides.codebaseIndexer ?? new FastGlobCodebaseIndexer();
+  const csvReader = overrides.csvReader ?? new FsCsvReader();
+  const claudeSkills = overrides.claudeSkills ?? new ClaudeSkillsService();
+  const opencodeSkills = overrides.opencodeSkills ?? new OpencodeSkillsService();
+
+  const selection = new SelectionService({ configStore, spaces, client, ui });
+  const setup = new SetupService({ configStore, selection, claudeSkills, opencodeSkills, ui });
+  const map = new MapService({ configStore, client, spaces, csvReader, ui });
+  const query = new QueryService({ configStore, spaces });
+  const context = new ContextService({ configStore });
+  const tools = new ToolService({ mcp });
+
+  return {
+    configStore,
+    client,
+    spaces,
+    ui,
+    mcp,
+    codebaseIndexer,
+    csvReader,
+    claudeSkills,
+    opencodeSkills,
+    selection,
+    setup,
+    map,
+    query,
+    context,
+    tools,
+  };
+}
+
+let _container;
+
+export function getContainer() {
+  if (!_container) _container = createContainer();
+  return _container;
+}
+
+export function resetContainer() {
+  _container = undefined;
+}

package/lib/impl/claude-skills-service.js

@@ -0,0 +1,13 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { SKILLS_DIR } from '../utils/package-root.js';
+import { syncSkills } from '../utils/skills-sync.js';
+
+export class ClaudeSkillsService {
+  sync() {
+    const skillsDir = path.join(os.homedir(), '.claude', 'skills');
+    const installed = syncSkills({ skillsDir: SKILLS_DIR, targets: [skillsDir] });
+    return { skillsDir, installed };
+  }
+}

package/lib/impl/fast-glob-codebase-indexer.js

@@ -0,0 +1,114 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import { stringify } from 'csv-stringify/sync';
+
+const DEFAULT_IGNORES = [
+  '**/.git/**', '**/.next/**', '**/.turbo/**', '**/.venv/**', '**/__pycache__/**',
+  '**/build/**', '**/coverage/**', '**/dist/**', '**/node_modules/**', '**/vendor/**',
+  '**/*.lock', '**/package-lock.json', '**/pnpm-lock.yaml', '**/yarn.lock',
+  '**/.DS_Store', '**/Thumbs.db',
+];
+
+const EXT_LANGUAGE = {
+  '.css': 'css', '.go': 'go', '.html': 'html', '.java': 'java', '.js': 'javascript',
+  '.jsx': 'javascript', '.json': 'json', '.md': 'markdown', '.py': 'python', '.rs': 'rust',
+  '.scss': 'scss', '.sql': 'sql', '.ts': 'typescript', '.tsx': 'typescript', '.vue': 'vue',
+  '.yaml': 'yaml', '.yml': 'yaml',
+};
+
+const SOURCE_EXTENSIONS = Object.keys(EXT_LANGUAGE);
+const NULL_BYTE = String.fromCharCode(0);
+
+function inferKind(rel) {
+  const base = path.basename(rel).toLowerCase();
+  if (base.includes('test') || base.includes('spec')) return 'test';
+  if (rel.includes('/components/') || rel.includes('\\components\\')) return 'component';
+  if (rel.includes('/pages/') || rel.includes('\\pages\\') || rel.includes('/app/')) return 'route';
+  if (rel.includes('/api/') || rel.includes('\\api\\')) return 'api';
+  if (rel.includes('/hooks/') || rel.includes('\\hooks\\')) return 'hook';
+  if (rel.includes('/utils/') || rel.includes('\\utils\\') || rel.includes('/lib/')) return 'utility';
+  return 'source';
+}
+
+function importsFrom(content) {
+  const imports = new Set();
+  const patterns = [
+    /^\s*import\s+.*?\s+from\s+['"]([^'"]+)['"]/gm,
+    /^\s*import\s+['"]([^'"]+)['"]/gm,
+    /^\s*const\s+.*?=\s+require\(['"]([^'"]+)['"]\)/gm,
+    /^\s*from\s+([\w.]+)\s+import\s+/gm,
+  ];
+  for (const re of patterns) {
+    for (const match of content.matchAll(re)) imports.add(match[1]);
+  }
+  return [...imports].slice(0, 40).join(', ');
+}
+
+function summarize(content) {
+  const lines = content.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  const comment = lines.find((l) => /^\/\/|^#|^\/\*|^\*|^<!--/.test(l));
+  return (comment || lines[0] || '').replace(/^\/\/|^#|^\/\*+|^\*|<!--|-->/g, '').trim().slice(0, 240);
+}
+
+function isBinaryBuffer(buf) {
+  const sample = buf.subarray(0, Math.min(buf.length, 8192));
+  for (let i = 0; i < sample.length; i++) {
+    const b = sample[i];
+    if (b === 0) return true;
+    if (b < 9 || (b > 13 && b < 32)) return true;
+  }
+  return false;
+}
+
+function readText(file, maxChars) {
+  const buf = fs.readFileSync(file);
+  if (isBinaryBuffer(buf)) return null;
+  let raw = buf.toString('utf8');
+  if (raw.indexOf(NULL_BYTE) !== -1) raw = raw.split(NULL_BYTE).join('');
+  return raw.length > maxChars ? `${raw.slice(0, maxChars)}\n\n[truncated]` : raw;
+}
+
+export class FastGlobCodebaseIndexer {
+  async index(rootDir, outFile, { maxChars = 12000, include } = {}) {
+    const root = path.resolve(rootDir || process.cwd());
+    const patterns = include?.length ? include : SOURCE_EXTENSIONS.map((ext) => `**/*${ext}`);
+    const files = await fg(patterns, {
+      cwd: root,
+      absolute: true,
+      dot: false,
+      ignore: DEFAULT_IGNORES,
+      onlyFiles: true,
+    });
+
+    const skipped = [];
+    const rows = [];
+    for (const file of files.sort()) {
+      const rel = path.relative(root, file).replace(/\\/g, '/');
+      const ext = path.extname(file).toLowerCase();
+      const content = readText(file, maxChars);
+      if (content === null) {
+        skipped.push(rel);
+        continue;
+      }
+      const stat = fs.statSync(file);
+      rows.push({
+        path: rel,
+        file_name: path.basename(file),
+        extension: ext.replace(/^\./, ''),
+        language: EXT_LANGUAGE[ext] || ext.replace(/^\./, ''),
+        kind: inferKind(rel),
+        loc: content.split(/\r?\n/).length,
+        bytes: stat.size,
+        imports: importsFrom(content),
+        summary: summarize(content),
+        content,
+      });
+    }
+
+    if (!rows.length) throw new Error(`No source files found in ${root}`);
+    fs.mkdirSync(path.dirname(path.resolve(outFile)), { recursive: true });
+    fs.writeFileSync(outFile, stringify(rows, { header: true }));
+    return { root, outFile: path.resolve(outFile), count: rows.length, skipped };
+  }
+}

package/lib/impl/file-config-store.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { CONFIG_NAME } from '../constants.js';
+import { normalizeBaseUrl, mcpUrl } from '../utils/url.js';
+
+export { normalizeBaseUrl, mcpUrl };
+
+export class FileConfigStore {
+  configPath() {
+    return path.join(os.homedir(), '.mantis', CONFIG_NAME);
+  }
+
+  load() {
+    const file = this.configPath();
+    if (!fs.existsSync(file)) return {};
+    try {
+      return JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      return {};
+    }
+  }
+
+  save(cfg) {
+    const file = this.configPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(cfg, null, 2)}\n`);
+  }
+
+  requireAuth() {
+    const cfg = this.load();
+    if (!cfg.apiKey || !cfg.apiBaseUrl) {
+      throw new Error('Run mantis setup first (API key + URL).');
+    }
+    return cfg;
+  }
+}

package/lib/impl/fs-csv-reader.js

@@ -0,0 +1,12 @@
+import fs from 'node:fs';
+import { parse } from 'csv-parse/sync';
+
+export class FsCsvReader {
+  readHeaders(file) {
+    const input = fs.readFileSync(file, 'utf8');
+    const rows = parse(input, { to_line: 1, relax_quotes: true });
+    const headers = rows[0] || [];
+    if (!headers.length) throw new Error('CSV has no header row.');
+    return headers.map((h) => String(h).trim()).filter(Boolean);
+  }
+}

package/lib/impl/http-mantis-client.js

@@ -0,0 +1,108 @@
+import { normalizeBaseUrl } from '../utils/url.js';
+
+function formatApiError(data, res) {
+  const raw = data.error || data.detail || res.statusText || `HTTP ${res.status}`;
+  if (typeof raw === 'string' && /<html/i.test(raw)) {
+    if (res.status >= 500) {
+      return 'Mantis server error (HTTP 500). If creating a thread, that name may already exist in this space.';
+    }
+    return `Mantis API error (HTTP ${res.status})`;
+  }
+  return typeof raw === 'string' ? raw : JSON.stringify(raw);
+}
+
+export class HttpMantisClient {
+  constructor(configStore) {
+    this.configStore = configStore;
+  }
+
+  _credentials() {
+    return this.configStore.requireAuth();
+  }
+
+  async request(method, pathname, { params, body } = {}) {
+    const { apiBaseUrl, apiKey } = this._credentials();
+    const root = normalizeBaseUrl(apiBaseUrl);
+    const url = new URL(pathname.startsWith('/') ? pathname : `/${pathname}`, `${root}/`);
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        if (v != null && v !== '') url.searchParams.set(k, String(v));
+      }
+    }
+    const res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        Accept: 'application/json',
+        ...(body ? { 'Content-Type': 'application/json' } : {}),
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    const text = await res.text();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : {};
+    } catch {
+      data = { error: text || res.statusText };
+    }
+    if (!res.ok) {
+      throw new Error(formatApiError(data, res));
+    }
+    return data;
+  }
+
+  listSpaces({ scope = 'accessible', limit = 20, offset = 0, q, space_id } = {}) {
+    return this.request('GET', '/api/v1/me/spaces/', {
+      params: { scope, limit, offset, q, space_id },
+    });
+  }
+
+  listSpaceStates(spaceId, { limit = 20, offset = 0 } = {}) {
+    return this.request('GET', '/api/v1/me/space-states/', {
+      params: { space_id: spaceId, limit, offset },
+    });
+  }
+
+  createSpaceState(spaceId, name) {
+    return this.request('POST', '/api/v1/me/space-states/', {
+      body: { space_id: spaceId, name },
+    });
+  }
+
+  createSpace({ name, isPublic = false }) {
+    return this.request('POST', '/api/v1/spaces/', {
+      body: { name, public: Boolean(isPublic) },
+    });
+  }
+
+  async createMapInSpace(spaceId, { file, mapName, dataTypes, selectedFields, fieldWeights }) {
+    const { apiBaseUrl, apiKey } = this._credentials();
+    const root = normalizeBaseUrl(apiBaseUrl);
+    const url = new URL(`/api/v1/spaces/${encodeURIComponent(spaceId)}/maps/`, `${root}/`);
+    const form = new FormData();
+    const bytes = await import('node:fs/promises').then((fs) => fs.readFile(file));
+    const name = await import('node:path').then((p) => p.basename(file));
+    form.set('file', new Blob([bytes]), name);
+    if (mapName) form.set('map_name', mapName);
+    if (dataTypes) form.set('data_types', JSON.stringify(dataTypes));
+    if (selectedFields) form.set('selected_fields', JSON.stringify(selectedFields));
+    if (fieldWeights) form.set('field_weights', JSON.stringify(fieldWeights));
+
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${apiKey}`, Accept: 'application/json' },
+      body: form,
+    });
+    const text = await res.text();
+    let data;
+    try {
+      data = text ? JSON.parse(text) : {};
+    } catch {
+      data = { error: text || res.statusText };
+    }
+    if (!res.ok) {
+      throw new Error(formatApiError(data, res));
+    }
+    return data;
+  }
+}

package/lib/impl/inquirer-ui-service.js

@@ -0,0 +1,73 @@
+import { confirm, input, password, search, select } from '@inquirer/prompts';
+
+export class InquirerUiService {
+  isCancel(err) {
+    return err?.name === 'ExitPromptError';
+  }
+
+  die(msg) {
+    console.error(`\n  ✖ ${msg}\n`);
+    process.exit(1);
+  }
+
+  banner(title, subtitle) {
+    console.log('');
+    console.log(`  \x1b[36m${title}\x1b[0m`);
+    if (subtitle) console.log(`  \x1b[2m${subtitle}\x1b[0m`);
+    console.log('');
+  }
+
+  success(msg) {
+    console.log(`  \x1b[32m✔\x1b[0m ${msg}`);
+  }
+
+  info(msg) {
+    console.log(`  \x1b[2m→\x1b[0m ${msg}`);
+  }
+
+  async promptInput(message, { default: def } = {}) {
+    try {
+      return await input({ message, default: def });
+    } catch (e) {
+      if (this.isCancel(e)) this.die('Cancelled.');
+      throw e;
+    }
+  }
+
+  async promptSecret(message, { default: def } = {}) {
+    if (def) return this.promptInput(message, { default: def });
+    try {
+      return await password({ message, mask: '•' });
+    } catch (e) {
+      if (this.isCancel(e)) this.die('Cancelled.');
+      throw e;
+    }
+  }
+
+  async promptSearch(message, source, { pageSize = 12 } = {}) {
+    try {
+      return await search({ message, pageSize, source });
+    } catch (e) {
+      if (this.isCancel(e)) this.die('Cancelled.');
+      throw e;
+    }
+  }
+
+  async promptSelect(message, choices) {
+    try {
+      return await select({ message, choices });
+    } catch (e) {
+      if (this.isCancel(e)) this.die('Cancelled.');
+      throw e;
+    }
+  }
+
+  async promptConfirm(message, { default: def = false } = {}) {
+    try {
+      return await confirm({ message, default: def });
+    } catch (e) {
+      if (this.isCancel(e)) this.die('Cancelled.');
+      throw e;
+    }
+  }
+}

package/lib/impl/mcp-client-service.js

@@ -0,0 +1,64 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+import { mcpUrl } from '../utils/url.js';
+
+export class McpClientService {
+  constructor(configStore) {
+    this.configStore = configStore;
+  }
+
+  _headers(cfg) {
+    return {
+      Authorization: `Bearer ${cfg.apiKey}`,
+      Accept: 'application/json',
+      ...(cfg.spaceStateId ? { 'X-Space-State-ID': String(cfg.spaceStateId) } : {}),
+    };
+  }
+
+  async _withClient(fn) {
+    const cfg = this.configStore.requireAuth();
+    if (!cfg.spaceStateId) {
+      throw new Error('No thread configured. Run: mantis setup or mantis select thread');
+    }
+    const transport = new StreamableHTTPClientTransport(new URL(mcpUrl(cfg)), {
+      requestInit: { headers: this._headers(cfg) },
+    });
+    const client = new Client({ name: 'mantisai-cli', version: '3.0.0' });
+    await client.connect(transport);
+    try {
+      return await fn(client);
+    } finally {
+      await client.close();
+    }
+  }
+
+  async listTools() {
+    const result = await this._withClient((client) => client.listTools());
+    return {
+      tools: (result.tools || []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema,
+      })),
+    };
+  }
+
+  async callTool(name, args = {}) {
+    const result = await this._withClient((client) => client.callTool({ name, arguments: args }));
+    if (result.isError) {
+      const msg = result.content?.find((c) => c.type === 'text')?.text || 'Tool call failed';
+      throw new Error(msg);
+    }
+    if (result.structuredContent) return result.structuredContent;
+    const text = result.content?.find((c) => c.type === 'text')?.text;
+    if (text) {
+      try {
+        return JSON.parse(text);
+      } catch {
+        return { text };
+      }
+    }
+    return result;
+  }
+}

package/lib/impl/opencode-skills-service.js

@@ -0,0 +1,17 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { SKILLS_DIR } from '../utils/package-root.js';
+import { syncSkills } from '../utils/skills-sync.js';
+
+export class OpencodeSkillsService {
+  sync(cwd = process.cwd()) {
+    const globalSkillsDir = path.join(os.homedir(), '.config', 'opencode', 'skills');
+    const projectSkillsDir = path.join(cwd, '.opencode', 'skills');
+    const installed = syncSkills({
+      skillsDir: SKILLS_DIR,
+      targets: [globalSkillsDir, projectSkillsDir],
+    });
+    return { globalSkillsDir, projectSkillsDir, installed };
+  }
+}

package/lib/impl/space-repository.js

@@ -0,0 +1,72 @@
+import { API_PAGE } from '../constants.js';
+import { parseSpaceIdFromInput } from '../utils/space-id.js';
+
+export class SpaceRepositoryImpl {
+  constructor(client) {
+    this.client = client;
+  }
+
+  async _paginate(fetchPage) {
+    const all = [];
+    let offset = 0;
+    for (;;) {
+      const { items, total } = await fetchPage(API_PAGE, offset);
+      const batch = items || [];
+      all.push(...batch);
+      if (batch.length < API_PAGE) break;
+      if (Number.isFinite(total) && all.length >= total) break;
+      offset += API_PAGE;
+    }
+    return all;
+  }
+
+  async fetchById(spaceId) {
+    const page = await this.client.listSpaces({
+      scope: 'accessible',
+      space_id: spaceId,
+      limit: 1,
+      offset: 0,
+    });
+    return page.spaces?.[0] ?? null;
+  }
+
+  async resolveFromInput(text) {
+    const id = parseSpaceIdFromInput(text);
+    if (!id) return null;
+    return this.fetchById(id);
+  }
+
+  async search({ q = '', limit = 20, offset = 0, scope = 'accessible' } = {}) {
+    const id = parseSpaceIdFromInput(q);
+    if (id) {
+      const one = await this.fetchById(id);
+      return { spaces: one ? [one] : [], total: one ? 1 : 0, limit: 1, offset: 0 };
+    }
+    const page = await this.client.listSpaces({
+      scope,
+      limit,
+      offset,
+      q: q.trim() || undefined,
+    });
+    return {
+      spaces: page.spaces || [],
+      total: page.total ?? (page.spaces || []).length,
+      limit: page.limit ?? limit,
+      offset: page.offset ?? offset,
+    };
+  }
+
+  fetchAccessible() {
+    return this._paginate(async (limit, offset) => {
+      const page = await this.client.listSpaces({ scope: 'accessible', limit, offset });
+      return { items: page.spaces, total: page.total };
+    });
+  }
+
+  fetchThreads(spaceId) {
+    return this._paginate(async (limit, offset) => {
+      const page = await this.client.listSpaceStates(spaceId, { limit, offset });
+      return { items: page.space_states, total: page.total };
+    });
+  }
+}

package/lib/interfaces/codebase-indexer.js

@@ -0,0 +1,5 @@
+/** @typedef {Object} CodebaseIndexer
+ * @property {(rootDir: string, outFile: string, opts?: object) => Promise<object>} index
+ */
+
+export {};

package/lib/interfaces/config-store.js

@@ -0,0 +1,11 @@
+/** @typedef {import('../types.js').MantisConfig} MantisConfig */
+
+/** @typedef {Object} ConfigStore
+ * @property {() => MantisConfig} load
+ * @property {(cfg: MantisConfig) => void} save
+ * @property {() => string} configPath
+ * @property {() => string[]} allConfigPaths
+ * @property {() => MantisConfig} requireAuth
+ */
+
+export {};

package/lib/interfaces/csv-reader.js

@@ -0,0 +1,5 @@
+/** @typedef {Object} CsvReader
+ * @property {(file: string) => string[]} readHeaders
+ */
+
+export {};

package/lib/interfaces/index.js

@@ -0,0 +1,7 @@
+export * from './config-store.js';
+export * from './mantis-client.js';
+export * from './mcp-client.js';
+export * from './space-repository.js';
+export * from './ui.js';
+export * from './codebase-indexer.js';
+export * from './csv-reader.js';

package/lib/interfaces/mantis-client.js

@@ -0,0 +1,13 @@
+/** @typedef {import('../types.js').Space} Space */
+/** @typedef {import('../types.js').Thread} Thread */
+/** @typedef {import('../types.js').SpacePage} SpacePage */
+
+/** @typedef {Object} MantisClient
+ * @property {(opts?: object) => Promise<SpacePage>} listSpaces
+ * @property {(spaceId: string, opts?: object) => Promise<{ space_states: Thread[], total: number }>} listSpaceStates
+ * @property {(spaceId: string, name?: string) => Promise<Thread>} createSpaceState
+ * @property {(opts: { name: string, isPublic?: boolean }) => Promise<Space>} createSpace
+ * @property {(spaceId: string, opts: object) => Promise<object>} createMapInSpace
+ */
+
+export {};

package/lib/interfaces/mcp-client.js

@@ -0,0 +1,6 @@
+/** @typedef {Object} McpClientService
+ * @property {() => Promise<{ tools: object[] }>} listTools
+ * @property {(name: string, args?: object) => Promise<object>} callTool
+ */
+
+export {};

package/lib/interfaces/space-repository.js

@@ -0,0 +1,13 @@
+/** @typedef {import('../types.js').Space} Space */
+/** @typedef {import('../types.js').SpacePage} SpacePage */
+/** @typedef {import('../types.js').Thread} Thread */
+
+/** @typedef {Object} SpaceRepository
+ * @property {(spaceId: string) => Promise<Space|null>} fetchById
+ * @property {(text: string) => Promise<Space|null>} resolveFromInput
+ * @property {(opts?: object) => Promise<SpacePage>} search
+ * @property {() => Promise<Space[]>} fetchAccessible
+ * @property {(spaceId: string) => Promise<Thread[]>} fetchThreads
+ */
+
+export {};

package/lib/interfaces/ui.js

@@ -0,0 +1,13 @@
+/** @typedef {Object} UiService
+ * @property {(msg: string) => never} die
+ * @property {(title: string, subtitle?: string) => void} banner
+ * @property {(msg: string) => void} success
+ * @property {(msg: string) => void} info
+ * @property {(message: string, opts?: object) => Promise<string>} promptInput
+ * @property {(message: string, opts?: object) => Promise<string>} promptSecret
+ * @property {(message: string, source: Function, opts?: object) => Promise<any>} promptSearch
+ * @property {(message: string, choices: object[]) => Promise<any>} promptSelect
+ * @property {(message: string, opts?: object) => Promise<boolean>} promptConfirm
+ */
+
+export {};