byterover-cli 1.7.2 → 2.0.0

package/dist/agent/infra/tools/implementations/spec-analyze-tool.js

@@ -1,78 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Domain category for knowledge classification.
- * Domains are created dynamically based on content semantics.
- */
-const DomainCategory = z
-    .string()
-    .min(1)
-    .describe('Domain category name. Create semantically meaningful domain names based on content (e.g., authentication, api_design, data_models). Use snake_case format.');
-/**
- * Text segment schema - represents a portion of the input data related to a domain
- */
-const TextSegmentSchema = z
-    .string()
-    .min(1)
-    .describe('A segment of text from the input data that relates to this domain category');
-/**
- * Input schema for detect domains tool
- */
-const DetectDomainsInputSchema = z
-    .object({
-    /** Detected domains with metadata and related text segments */
-    domains: z
-        .array(z.object({
-        category: DomainCategory.describe('Semantically meaningful domain category name (snake_case, e.g., authentication, api_design)'),
-        textSegments: z
-            .array(TextSegmentSchema)
-            .min(1)
-            .describe('Array of text segments from the input data that relate to this domain. Each segment should be a meaningful excerpt that demonstrates why this domain is relevant.'),
-    }))
-        .describe('Array of detected domains with their related text segments from the input data'),
-});
-/**
- * Execute function for detect domains tool with typed input
- */
-async function executeDetectDomains(input, _context) {
-    const { domains } = input;
-    return {
-        domains,
-    };
-}
-/**
- * Creates the detect domains tool.
- *
- * @returns Configured detect domains tool
- */
-export function createSpecAnalyzeTool() {
-    return {
-        description: `Use this tool to analyze input data and detect which knowledge domains are present. For each detected domain, you must also extract the specific text segments from the input data that relate to that domain.
-
-This tool should be the first tool to call when you want to understand new data, unless you already know what you are looking for.
-
-**Dynamic Domain Creation:**
-Domains are created dynamically based on the semantics of the content. Choose domain names that:
-- Are descriptive and semantically meaningful
-- Use snake_case format (1-3 words)
-- Group related concepts together
-- Examples: \`authentication\`, \`api_design\`, \`data_models\`, \`error_handling\`, \`ui_components\`, \`testing_patterns\`
-
-**For each domain you detect:**
-1. Create a semantically meaningful domain category name based on the content
-2. Extract relevant text segments from the input data that demonstrate why this domain is relevant
-3. Each text segment should be a meaningful excerpt (not just keywords) that shows the connection to the domain
-4. Only include domains that are actually present in the data
-
-**Domain Naming Guidelines:**
-- Use noun-based names that describe the category (e.g., \`authentication\` not \`how_to_authenticate\`)
-- Avoid overly generic names (e.g., \`misc\`, \`other\`, \`general\`)
-- Avoid overly specific names that only fit one topic
-- Consolidate related concepts under the same domain
-
-The text segments will be used later to create organized knowledge topics, so they should be substantial enough to provide context.`,
-        execute: executeDetectDomains,
-        id: ToolName.SPEC_ANALYZE,
-        inputSchema: DetectDomainsInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/write-memory-tool.d.ts

@@ -1,13 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { MemoryManager } from '../../memory/memory-manager.js';
-/**
- * Creates the write memory tool.
- *
- * Stores content in the agent's memory as a scratch pad for maintaining context
- * across tool invocations. Memories persist across sessions and can be tagged
- * for organization.
- *
- * @param memoryManager - Memory manager service dependency
- * @returns Configured write memory tool
- */
-export declare function createWriteMemoryTool(memoryManager: MemoryManager): Tool;

package/dist/agent/infra/tools/implementations/write-memory-tool.js

@@ -1,52 +0,0 @@
-import { z } from 'zod';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Input schema for write memory tool.
- */
-const WriteMemoryInputSchema = z
-    .object({
-    content: z
-        .string()
-        .min(1, 'Memory content cannot be empty')
-        .max(10_000, 'Memory content cannot exceed 10,000 characters')
-        .describe('The content to store in memory'),
-    pinned: z
-        .boolean()
-        .optional()
-        .describe('Whether to pin this memory for auto-loading (default: false)'),
-})
-    .strict();
-/**
- * Creates the write memory tool.
- *
- * Stores content in the agent's memory as a scratch pad for maintaining context
- * across tool invocations. Memories persist across sessions and can be tagged
- * for organization.
- *
- * @param memoryManager - Memory manager service dependency
- * @returns Configured write memory tool
- */
-export function createWriteMemoryTool(memoryManager) {
-    return {
-        description: 'Write content to agent memory as a scratch pad. Use this to store intermediate results, findings, or context that should persist across tool calls. Memories can be tagged and pinned for easy retrieval.',
-        async execute(input, _context) {
-            const { content, pinned } = input;
-            // Create memory with agent source
-            const memory = await memoryManager.create({
-                content,
-                metadata: {
-                    pinned: pinned ?? false,
-                    source: 'agent',
-                },
-            });
-            // Return formatted result
-            return {
-                content: memory.content,
-                createdAt: new Date(memory.createdAt).toISOString(),
-                id: memory.id,
-            };
-        },
-        id: ToolName.WRITE_MEMORY,
-        inputSchema: WriteMemoryInputSchema,
-    };
-}

package/dist/agent/infra/tools/implementations/write-todos-tool.d.ts

@@ -1,13 +0,0 @@
-import type { Tool } from '../../../core/domain/tools/types.js';
-import type { ITodoStorage } from '../../../core/interfaces/i-todo-storage.js';
-/**
- * Creates the write todos tool.
- *
- * Manages a structured task list for planning-based execution.
- * Validates that only one task is in_progress at any time.
- * Stores todos in session-based storage.
- *
- * @param todoStorage - Storage service for persisting todos
- * @returns Configured write todos tool
- */
-export declare function createWriteTodosTool(todoStorage: ITodoStorage): Tool;

package/dist/agent/infra/tools/implementations/write-todos-tool.js

@@ -1,121 +0,0 @@
-import { z } from 'zod';
-import { TODO_STATUSES } from '../../../core/domain/todos/types.js';
-import { ToolName } from '../../../core/domain/tools/constants.js';
-/**
- * Schema for a single todo item.
- */
-const TodoSchema = z.object({
-    activeForm: z
-        .string()
-        .min(1)
-        .describe('Present continuous form shown during execution (e.g., "Running tests")'),
-    content: z.string().min(1).describe('Imperative description of the task (e.g., "Run tests")'),
-    id: z.string().min(1).describe('Unique identifier for the todo item'),
-    status: z
-        .enum(TODO_STATUSES)
-        .describe('Task status: pending, in_progress (only ONE at a time), completed, or cancelled'),
-});
-/**
- * Input schema for write todos tool.
- */
-const WriteTodosInputSchema = z
-    .object({
-    todos: z.array(TodoSchema).min(1).describe('List of todo items to track'),
-})
-    .strict();
-/**
- * Tool description with detailed usage guidance.
- * This helps the LLM understand when to use the tool and how.
- */
-const TOOL_DESCRIPTION = `Use this tool to create and manage a structured task list for the current session.`;
-/**
- * Validates that only one todo is in_progress.
- *
- * @param todos - Array of todos to validate
- * @returns Error message if invalid, null if valid
- */
-function validateSingleInProgress(todos) {
-    const inProgressCount = todos.filter((todo) => todo.status === 'in_progress').length;
-    if (inProgressCount > 1) {
-        return `Invalid parameters: Only one task can be "in_progress" at a time. Found ${inProgressCount} tasks in progress.`;
-    }
-    return null;
-}
-/**
- * Formats the todo list for LLM response.
- * Uses opencode-style status icons: [✓] for completed, [ ] for others.
- *
- * @param todos - Array of todos
- * @returns Formatted string representation
- */
-function formatTodosForLLM(todos) {
-    const lines = ['Todo list updated:'];
-    for (const todo of todos) {
-        const checkbox = todo.status === 'completed' ? '[✓]' : '[ ]';
-        const statusLabel = todo.status === 'in_progress' ? ' (in_progress)' : '';
-        lines.push(`${checkbox} ${todo.content}${statusLabel}`);
-    }
-    const stats = getTodoStats(todos);
-    const progressLines = ['', `Progress: ${stats.completed}/${stats.total} completed`];
-    if (stats.inProgress > 0) {
-        const currentTask = todos.find((t) => t.status === 'in_progress');
-        if (currentTask) {
-            progressLines.push(`Currently: ${currentTask.activeForm}`);
-        }
-    }
-    return [...lines, ...progressLines].join('\n');
-}
-/**
- * Gets statistics about the todo list.
- *
- * @param todos - Array of todos
- * @returns Statistics object
- */
-function getTodoStats(todos) {
-    return {
-        cancelled: todos.filter((t) => t.status === 'cancelled').length,
-        completed: todos.filter((t) => t.status === 'completed').length,
-        inProgress: todos.filter((t) => t.status === 'in_progress').length,
-        pending: todos.filter((t) => t.status === 'pending').length,
-        total: todos.length,
-    };
-}
-/**
- * Creates the write todos tool.
- *
- * Manages a structured task list for planning-based execution.
- * Validates that only one task is in_progress at any time.
- * Stores todos in session-based storage.
- *
- * @param todoStorage - Storage service for persisting todos
- * @returns Configured write todos tool
- */
-export function createWriteTodosTool(todoStorage) {
-    return {
-        description: TOOL_DESCRIPTION,
-        async execute(input, context) {
-            const { todos } = input;
-            // Validate only one in_progress
-            const validationError = validateSingleInProgress(todos);
-            if (validationError) {
-                return validationError;
-            }
-            // Store todos in session storage
-            const sessionId = context?.sessionId ?? 'default';
-            await todoStorage.update(sessionId, todos);
-            // Format response for LLM
-            const llmContent = formatTodosForLLM(todos);
-            // Calculate incomplete count for smart title
-            const incompleteCount = todos.filter((t) => t.status !== 'completed').length;
-            // Return both LLM content and display content with metadata
-            return {
-                llmContent,
-                metadata: { todos },
-                returnDisplay: { todos },
-                title: `${incompleteCount} todos`,
-            };
-        },
-        id: ToolName.WRITE_TODOS,
-        inputSchema: WriteTodosInputSchema,
-    };
-}

package/dist/oclif/commands/curate.d.ts

@@ -1,21 +0,0 @@
-import { Command } from '@oclif/core';
-import { ICurateUseCase } from '../../server/core/interfaces/usecase/i-curate-use-case.js';
-export default class Curate extends Command {
-    static args: {
-        context: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
-    };
-    static description: string;
-    static examples: string[];
-    static flags: {
-        verbose?: import("@oclif/core/interfaces").BooleanFlag<boolean> | undefined;
-        files: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        folder: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        headless: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    protected createUseCase(options: {
-        format: 'json' | 'text';
-        headless: boolean;
-    }): ICurateUseCase;
-    run(): Promise<void>;
-}

package/dist/oclif/commands/curate.js

@@ -1,96 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { isDevelopment } from '../../server/config/environment.js';
-import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
-import { createTokenStore } from '../../server/infra/storage/token-store.js';
-import { HeadlessTerminal } from '../../server/infra/terminal/headless-terminal.js';
-import { OclifTerminal } from '../../server/infra/terminal/oclif-terminal.js';
-import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
-import { CurateUseCase } from '../../server/infra/usecase/curate-use-case.js';
-export default class Curate extends Command {
-    static args = {
-        context: Args.string({
-            description: 'Knowledge context: patterns, decisions, errors, or insights',
-            required: false,
-        }),
-    };
-    static description = `Curate context to the context tree (connects to running brv instance)
-
-Requires a running brv instance. Start one with: brv
-
-Good examples:
-- "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"
-- "API rate limit is 100 req/min per user. Implemented using Redis with sliding window in rateLimiter.ts"
-Bad examples:
-- "Authentication" or "JWT tokens" (too vague, lacks context)
-- "Rate limiting" (no implementation details or file references)`;
-    static examples = [
-        '# Curate context - queues task for background processing',
-        '<%= config.bin %> <%= command.id %> "Auth uses JWT with 24h expiry. Tokens stored in httpOnly cookies via authMiddleware.ts"',
-        '',
-        '# Include relevant files for comprehensive context (max 5 files)',
-        '<%= config.bin %> <%= command.id %> "Authentication middleware validates JWT tokens" -f src/middleware/auth.ts',
-        '',
-        '# Multiple files',
-        '<%= config.bin %> <%= command.id %> "JWT authentication implementation" --files src/auth/jwt.ts --files docs/auth.md',
-        '',
-        '# Folder pack - analyze and curate entire folder',
-        '<%= config.bin %> <%= command.id %> --folder src/auth/',
-        '',
-        '# Folder pack with context',
-        '<%= config.bin %> <%= command.id %> "Analyze authentication module" -d src/auth/',
-    ];
-    static flags = {
-        files: Flags.string({
-            char: 'f',
-            description: 'Include specific file paths for critical context (max 5 files)',
-            multiple: true,
-        }),
-        folder: Flags.string({
-            char: 'd',
-            description: 'Folder path to pack and analyze (triggers folder pack flow)',
-            multiple: true,
-        }),
-        format: Flags.string({
-            default: 'text',
-            description: 'Output format (text or json)',
-            options: ['text', 'json'],
-        }),
-        headless: Flags.boolean({
-            default: false,
-            description: 'Run in headless mode (no TTY required, suitable for automation)',
-        }),
-        ...(isDevelopment()
-            ? {
-                verbose: Flags.boolean({
-                    char: 'v',
-                    default: false,
-                    description: 'Enable verbose debug output [Development only]',
-                }),
-            }
-            : {}),
-    };
-    createUseCase(options) {
-        const tokenStore = createTokenStore();
-        const globalConfigStore = new FileGlobalConfigStore();
-        const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
-        // Use HeadlessTerminal for headless mode or JSON format
-        const terminal = options.headless || options.format === 'json'
-            ? new HeadlessTerminal({ failOnPrompt: true, outputFormat: options.format })
-            : new OclifTerminal(this);
-        return new CurateUseCase({ terminal, trackingService });
-    }
-    async run() {
-        const { args, flags: rawFlags } = await this.parse(Curate);
-        const flags = rawFlags;
-        const format = (flags.format ?? 'text');
-        const headless = flags.headless ?? false;
-        return this.createUseCase({ format, headless }).run({
-            context: args.context,
-            files: flags.files,
-            folders: flags.folder,
-            format,
-            headless,
-            verbose: flags.verbose,
-        });
-    }
-}

package/dist/oclif/commands/init.d.ts

@@ -1,18 +0,0 @@
-import { Command } from '@oclif/core';
-import { IInitUseCase } from '../../server/core/interfaces/usecase/i-init-use-case.js';
-export default class Init extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        headless: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        space: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        team: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    protected createUseCase(options: {
-        format: 'json' | 'text';
-        headless: boolean;
-    }): IInitUseCase;
-    run(): Promise<void>;
-}

package/dist/oclif/commands/init.js

@@ -1,129 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import { getCurrentConfig } from '../../server/config/environment.js';
-import { HttpCogitPullService } from '../../server/infra/cogit/http-cogit-pull-service.js';
-import { ProjectConfigStore } from '../../server/infra/config/file-config-store.js';
-import { ConnectorManager } from '../../server/infra/connectors/connector-manager.js';
-import { RuleTemplateService } from '../../server/infra/connectors/shared/template-service.js';
-import { FileContextTreeService } from '../../server/infra/context-tree/file-context-tree-service.js';
-import { FileContextTreeSnapshotService } from '../../server/infra/context-tree/file-context-tree-snapshot-service.js';
-import { FileContextTreeWriterService } from '../../server/infra/context-tree/file-context-tree-writer-service.js';
-import { FsFileService } from '../../server/infra/file/fs-file-service.js';
-import { HttpSpaceService } from '../../server/infra/space/http-space-service.js';
-import { FileGlobalConfigStore } from '../../server/infra/storage/file-global-config-store.js';
-import { createTokenStore } from '../../server/infra/storage/token-store.js';
-import { HttpTeamService } from '../../server/infra/team/http-team-service.js';
-import { FsTemplateLoader } from '../../server/infra/template/fs-template-loader.js';
-import { HeadlessTerminal } from '../../server/infra/terminal/headless-terminal.js';
-import { OclifTerminal } from '../../server/infra/terminal/oclif-terminal.js';
-import { MixpanelTrackingService } from '../../server/infra/tracking/mixpanel-tracking-service.js';
-import { InitUseCase } from '../../server/infra/usecase/init-use-case.js';
-export default class Init extends Command {
-    static description = `Initialize a project with ByteRover
-
-Sets up ByteRover for the current project by selecting a team and space.
-For headless mode, you must provide --team and --space (ID or name).`;
-    static examples = [
-        '# Interactive initialization',
-        '<%= config.bin %> <%= command.id %>',
-        '',
-        '# Force re-initialization',
-        '<%= config.bin %> <%= command.id %> --force',
-        '',
-        '# Headless mode with team/space names',
-        '<%= config.bin %> <%= command.id %> --headless --team my-team --space my-space --format json',
-        '',
-        '# Headless mode with team/space IDs',
-        '<%= config.bin %> <%= command.id %> --headless --team team-abc123 --space space-xyz789 --format json',
-    ];
-    static flags = {
-        force: Flags.boolean({
-            char: 'f',
-            default: false,
-            description: 'Force re-initialization without confirmation prompt',
-        }),
-        format: Flags.string({
-            default: 'text',
-            description: 'Output format (text or json)',
-            options: ['text', 'json'],
-        }),
-        headless: Flags.boolean({
-            default: false,
-            description: 'Run in headless mode (no TTY required, requires --team and --space)',
-        }),
-        space: Flags.string({
-            description: 'Space ID or name (required for headless mode)',
-        }),
-        team: Flags.string({
-            description: 'Team ID or name (required for headless mode)',
-        }),
-    };
-    createUseCase(options) {
-        const envConfig = getCurrentConfig();
-        const tokenStore = createTokenStore();
-        const globalConfigStore = new FileGlobalConfigStore();
-        const trackingService = new MixpanelTrackingService({ globalConfigStore, tokenStore });
-        const contextTreeSnapshotService = new FileContextTreeSnapshotService();
-        const fileService = new FsFileService();
-        const templateLoader = new FsTemplateLoader(fileService);
-        const templateService = new RuleTemplateService(templateLoader);
-        // Use HeadlessTerminal for headless mode or JSON format
-        const terminal = options.headless || options.format === 'json'
-            ? new HeadlessTerminal({ failOnPrompt: true, outputFormat: options.format })
-            : new OclifTerminal(this);
-        // Create ConnectorManager
-        const connectorManager = new ConnectorManager({
-            fileService,
-            projectRoot: process.cwd(),
-            templateService,
-        });
-        return new InitUseCase({
-            cogitPullService: new HttpCogitPullService({
-                apiBaseUrl: envConfig.cogitApiBaseUrl,
-            }),
-            connectorManager,
-            contextTreeService: new FileContextTreeService(),
-            contextTreeSnapshotService,
-            contextTreeWriterService: new FileContextTreeWriterService({
-                snapshotService: contextTreeSnapshotService,
-            }),
-            fileService,
-            projectConfigStore: new ProjectConfigStore(),
-            spaceService: new HttpSpaceService({
-                apiBaseUrl: envConfig.apiBaseUrl,
-            }),
-            teamService: new HttpTeamService({
-                apiBaseUrl: envConfig.apiBaseUrl,
-            }),
-            terminal,
-            tokenStore,
-            trackingService,
-        });
-    }
-    async run() {
-        const { flags: rawFlags } = await this.parse(Init);
-        const flags = rawFlags;
-        const format = (flags.format ?? 'text');
-        const headless = flags.headless ?? false;
-        // Validate headless mode requirements
-        if (headless && (!flags.team || !flags.space)) {
-            const terminal = new HeadlessTerminal({ failOnPrompt: true, outputFormat: format });
-            const response = {
-                command: 'init',
-                data: {
-                    error: 'Headless mode requires both --team and --space flags',
-                    status: 'error',
-                },
-                success: false,
-                timestamp: new Date().toISOString(),
-            };
-            terminal.writeFinalResponse(response);
-            return;
-        }
-        await this.createUseCase({ format, headless }).run({
-            force: flags.force ?? false,
-            format,
-            spaceId: flags.space,
-            teamId: flags.team,
-        });
-    }
-}

package/dist/server/core/domain/entities/context-tree-index.d.ts

@@ -1,26 +0,0 @@
-/**
- * Represents a node in the context tree structure.
- * Can be either a folder (with children) or a file.
- */
-export interface ContextNode {
-    children?: ContextNode[];
-    name: string;
-    path: string;
-    type: 'file' | 'folder';
-}
-/**
- * Represents the index.json structure for the context tree.
- * This index captures the hierarchical structure of the context tree.
- */
-export declare class ContextTreeIndex {
-    readonly domains: ContextNode[];
-    constructor(domains: ContextNode[]);
-    /**
-     * Creates a ContextTreeIndex from JSON format
-     */
-    static fromJson(json: Record<string, unknown>): ContextTreeIndex;
-    /**
-     * Serializes the index to JSON format
-     */
-    toJson(): Record<string, unknown>;
-}

package/dist/server/core/domain/entities/context-tree-index.js

@@ -1,27 +0,0 @@
-/**
- * Represents the index.json structure for the context tree.
- * This index captures the hierarchical structure of the context tree.
- */
-export class ContextTreeIndex {
-    domains;
-    constructor(domains) {
-        if (domains.length === 0) {
-            throw new Error('Context tree must have at least one domain');
-        }
-        this.domains = domains;
-    }
-    /**
-     * Creates a ContextTreeIndex from JSON format
-     */
-    static fromJson(json) {
-        return new ContextTreeIndex(json.domains);
-    }
-    /**
-     * Serializes the index to JSON format
-     */
-    toJson() {
-        return {
-            domains: this.domains,
-        };
-    }
-}

package/dist/server/core/domain/entities/event.d.ts

@@ -1,8 +0,0 @@
-/**
- * Array of all supported Events.
- */
-export declare const EVENT_VALUES: readonly ["repl", "auth:sign_in", "auth:signed_out", "auth:token_invalid", "space:init", "space:changed", "rule:generate", "connectors:configure", "connector:install", "mem:status", "mem:curate", "mem:pull", "mem:push", "mem:query", "onboarding:init_completed", "onboarding:curate_completed", "onboarding:query_completed", "onboarding:skipped", "onboarding:completed", "init"];
-export type EventName = (typeof EVENT_VALUES)[number];
-export interface PropertyDict {
-    [key: string]: any;
-}

package/dist/server/core/domain/entities/event.js

@@ -1,25 +0,0 @@
-/**
- * Array of all supported Events.
- */
-export const EVENT_VALUES = [
-    'repl',
-    'auth:sign_in',
-    'auth:signed_out',
-    'auth:token_invalid',
-    'space:init',
-    'space:changed',
-    'rule:generate',
-    'connectors:configure',
-    'connector:install',
-    'mem:status',
-    'mem:curate',
-    'mem:pull',
-    'mem:push',
-    'mem:query',
-    'onboarding:init_completed',
-    'onboarding:curate_completed',
-    'onboarding:query_completed',
-    'onboarding:skipped',
-    'onboarding:completed',
-    'init',
-];