Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

10.3 KB
Raw Blame
import {
  type AnyBlockDefinition,
  type BlockAlias,
  type BlockName,
  BlockRegistry,
  type FileTypeString,
  type MimeType,
} from '@core/block';
import type { SubType } from '@entity';
import type { ItemType } from '@service-storage/client';
import type { BasicDocumentSubTypeProperty } from '@service-storage/generated/schemas';
import type { BasicDocumentFileType } from '@service-storage/generated/schemas/basicDocumentFileType';
import {
  ENABLE_DOCX_TO_PDF,
  enableDocxEditor,
  isFeatureEnabled,
} from './featureFlags';
import { DefaultFilename } from './filename';

const discoveredBlockDefinitions = Object.values<AnyBlockDefinition>(
  import.meta.glob('../../../features/*/definition.ts', {
    eager: true,
    import: 'definition',
  })
);

const definitionNames = discoveredBlockDefinitions.map(
  (definition) => definition.name
);
const duplicateDefinitionNames = definitionNames.filter(
  (name, index) => definitionNames.indexOf(name) !== index
);
if (duplicateDefinitionNames.length > 0) {
  throw new Error(
    `Duplicate block definitions discovered: ${[...new Set(duplicateDefinitionNames)].join(', ')}`
  );
}

// Every block needs a module. `write` (DOCX) is the collaborative DOCX editor
// when it is enabled; otherwise `verifyBlockName` resolves it to `pdf`.
const missingBlockDefinitions = BlockRegistry.filter(
  (name) => !definitionNames.includes(name)
);
if (missingBlockDefinitions.length > 0) {
  throw new Error(
    `Missing block definitions: ${missingBlockDefinitions.join(', ')}`
  );
}

export const blocks = Object.fromEntries(
  discoveredBlockDefinitions.map((definition) => [definition.name, definition])
) as Readonly<Record<BlockName, Readonly<AnyBlockDefinition>>>;

export const blockAcceptedMimetypeToFileExtension: Record<
  MimeType,
  FileTypeString
> = {};

export const blockAcceptedFileExtensionToMimeType: Record<
  FileTypeString,
  MimeType
> = {};

const fileTypeToBlockName_: Record<string, BlockName> = {};

// Map from alias names to their base block names
const aliasToBlockName_: Record<string, BlockName> = {};

// Map from base block names to their aliases
const blockNameToAliases: Partial<Record<BlockName, string[]>> = {};

export const blockAcceptedFileExtensionSet = new Set<string>();

// @ts-ignore This type is built below
export const blockNameToFileExtensionSet: Record<
  BlockName,
  Set<FileTypeString>
> = {};
// @ts-ignore This type is built below
const blockNameToMimeTypeSet: Record<BlockName, Set<MimeType>> = {};
const blockNameToDefaultFilename: Partial<
  Record<BlockName | BlockAlias, string>
> = {};

for (const [name, block] of Object.entries(blocks)) {
  blockNameToFileExtensionSet[name as BlockName] = new Set();
  blockNameToMimeTypeSet[name as BlockName] = new Set();

  // Process aliases
  if (block.aliases) {
    blockNameToAliases[name as BlockName] = block.aliases.map(
      (alias) => alias.name
    );
    for (const alias of block.aliases) {
      aliasToBlockName_[alias.name] = name as BlockName;
      if (alias.defaultFileName) {
        blockNameToDefaultFilename[alias.name] = alias.defaultFileName;
      }
    }
  } else {
    blockNameToAliases[name as BlockName] = [];
  }

  for (const [fileExtension, mimeType] of Object.entries(block.accepted)) {
    fileTypeToBlockName_[fileExtension] = name as BlockName;
    blockAcceptedFileExtensionSet.add(fileExtension);
    blockNameToFileExtensionSet[name as BlockName].add(fileExtension);
    if (!mimeType) continue;
    // first instance wins for now
    blockAcceptedMimetypeToFileExtension[mimeType] ??= fileExtension;
    blockNameToMimeTypeSet[name as BlockName].add(mimeType);
    blockAcceptedFileExtensionToMimeType[fileExtension] ??= mimeType;
  }
  if (block.defaultFilename) {
    blockNameToDefaultFilename[name as BlockName] = block.defaultFilename;
  }
}

function _blockAcceptsMimeType(blockName: BlockName, mimeType: MimeType) {
  return blockNameToMimeTypeSet[blockName].has(mimeType);
}

export function blockAcceptsFileExtension(
  blockName: BlockName,
  fileExtension: string
) {
  return blockNameToFileExtensionSet[blockName].has(fileExtension);
}

export const blockNameToFileExtensions = Object.fromEntries(
  Object.entries(blockNameToFileExtensionSet).map(([name, extensions]) => [
    name,
    Array.from(extensions),
  ])
) as Record<BlockName, string[]>;

export const blockNameToMimeTypes = Object.fromEntries(
  Object.entries(blockNameToMimeTypeSet).map(([name, mimeTypes]) => [
    name,
    Array.from(mimeTypes),
  ])
) as Record<BlockName, string[]>;

const _blockAcceptedMimeTypes = Object.keys(
  blockAcceptedMimetypeToFileExtension
);

const _blockAcceptedFileExtensions = Array.from(blockAcceptedFileExtensionSet);

/**
 * Check if a string is a block alias
 */
export function isBlockAlias(name: string): name is BlockAlias {
  return name in aliasToBlockName_;
}

/**
 * Get the base block name for an alias, or return the original name if not an alias
 */
export function resolveBlockAlias(name: BlockName | BlockAlias): BlockName {
  return aliasToBlockName_[name] || (name as BlockName);
}

/**
 * Get the name of a block from a its own name or a file type. Built using the
 * types registered in block definitions.
 * @example
 * getBlockName('docx') // 'write'
 * getBlockName('svg') // 'image'
 * getBlockName('chat') // 'chat'
 * getBlockName('task') // 'task'
 * getBlockName('junk') // undefined
 * @param blockOrFiletype - The block name or file type like 'py', 'md', 'chat',
 *     'png', etc.
 * @param icon - Whether to return the icon name or the block name. In the case of
 *     'docx', icon should still show as docx icon, not pdf.
 * @return Either the name of the block or 'unknown' if there is no
 *     appropriate block.
 */
export function fileTypeToBlockName(
  blockOrFiletype?: string | null,
  // For docx: icon should still show as docx icon, not pdf
  icon?: boolean
): BlockName | BlockAlias {
  if (!blockOrFiletype) return 'unknown';

  if (blockOrFiletype === 'channel_message') return 'channel';
  if (blockOrFiletype === 'agent_session') return 'agent';
  if (blockOrFiletype === 'calendar_event') return 'calendar';
  if (blockOrFiletype === 'automation') return 'routine';

  // CRM entity types map to their dedicated blocks (entity type !== block name).
  if (blockOrFiletype === 'crm_company') return 'company';
  if (blockOrFiletype === 'crm_contact') return 'contact';
  if (blockOrFiletype === 'crm_pipeline') return 'pipeline';

  if (blockOrFiletype === 'docx' || blockOrFiletype === 'write') {
    if (isFeatureEnabled(enableDocxEditor)) return 'write';
    if (ENABLE_DOCX_TO_PDF) return icon ? 'write' : 'pdf';
  }

  if (isBlockAlias(blockOrFiletype)) {
    return blockOrFiletype;
  }

  if (BlockRegistry.includes(blockOrFiletype as any)) {
    return blockOrFiletype as BlockName;
  }

  return fileTypeToBlockName_[blockOrFiletype] ?? 'unknown';
}

/**
 * Get the name of a block from a its own name, aliased name,  or a file type.
 * @example
 * getBlockName('task') // 'md'
 * getBlockName('junk') // undefined
 * @param blockOrFiletype - The block name or file type like 'py', 'md', 'chat',
 *     'png', etc.
 * @return Either the name of the block or 'unknown' if there is no
 *     appropriate block.
 */
export function fileTypeToResolvedBlockName(
  blockOrFiletype?: string | null
): BlockName {
  return resolveBlockAlias(fileTypeToBlockName(blockOrFiletype));
}

/**
 * Get the default display name for an unnamed file of a particular block.
 */
export function blockNameToDefaultFile(block?: BlockName | string | null) {
  if (!block) return DefaultFilename;
  if (block in blockNameToDefaultFilename) {
    return (
      blockNameToDefaultFilename[block as BlockName | BlockAlias] ||
      DefaultFilename
    );
  }
  return DefaultFilename;
}

export type ItemLike = {
  type:
    | ItemType
    | 'agent'
    | 'initiative'
    | 'call'
    | 'crm_company'
    | 'calendar_event'
    | 'database';
  fileType?: BasicDocumentFileType;
  subType?: SubType | BasicDocumentSubTypeProperty;
  name?: string;
};

/**
 * Get a block name from an item-shaped object.
 * @example
 * itemToBlockName({ type: 'document', fileType: 'docx' }) // 'write'
 * itemToBlockName({ type: 'document', fileType: 'py' }) // 'code'
 * itemToBlockName({ type: 'document', fileType: 'md', subType: { type: 'task', is_completed: false } }) // 'task'
 * itemToBlockName({ type: 'chat' }) // 'chat'
 * @return The block name
 */
export function itemToBlockName(
  item: ItemLike,
  icon?: boolean
): BlockName | BlockAlias {
  const subTypeName =
    item.subType && 'type' in item.subType
      ? (item.subType.type as string)
      : undefined;
  if (subTypeName && isBlockAlias(subTypeName)) {
    return subTypeName;
  }
  if (item.fileType) {
    return fileTypeToBlockName(item.fileType, icon);
  }
  if (item.type === 'agent_session') return 'agent';
  if (item.type === 'channel_thread') return 'channel';
  return fileTypeToBlockName(item.type, icon);
}

/**
 * Get a flattened block name from an item-shaped object. Ignoring any block \
 * aliases.
 * @example
 * itemToBlockName({ type: 'document', fileType: 'md', subType: 'task' }) // 'md'
 * @return The block name
 */
export function itemToResolvedBlockName(item: ItemLike) {
  const maybeAliased = itemToBlockName(item);
  return resolveBlockAlias(maybeAliased);
}

/**
 * Get the name of an item or its block-specific fallback name if the name in storage is
 *     the empty string.
 * @example
 * itemToSafeName({ type: 'document', fileType: 'md', fileName: 'My Cool Note' }) // 'My Cool Note'
 * itemToBlockName({ type: 'document', fileType: 'py' }) // 'Unknown Filename'
 * itemToBlockName({ type: 'chat' }) // 'New Chat'
 * @return A safe name for the item to display.
 */
export function itemToSafeName(item: ItemLike): string {
  if (typeof item.name === 'string' && item.name.length > 0) {
    return item.name;
  }
  return blockNameToDefaultFile(itemToBlockName(item) || 'unknown');
}

/**
 * Return name as a known block name if it matches or 'unknown' if not found.
 * @returns
 */
export function verifyBlockName(
  name: string | undefined
): BlockName | BlockAlias {
  if (!name) return 'unknown';
  if (name === 'automation') return 'routine';
  if (name === 'write') {
    if (isFeatureEnabled(enableDocxEditor)) return 'write';
    if (ENABLE_DOCX_TO_PDF) return 'pdf';
  }
  if (isBlockAlias(name)) return name;
  if (name && name in blocks) return name as BlockName;
  return 'unknown';
}