@meistrari/chat-nuxt 1.12.0 → 1.14.0

package/dist/runtime/server/utils/chat-api-proxy.d.ts

@@ -0,0 +1,6 @@
+import type { H3Event } from 'h3';
+export declare function mapVaultProxyPath(path: string): string;
+export declare function mapWorkspaceProxyPath(path: string): string;
+export declare function prefixProxyPath(prefix: string, path: string): string;
+export declare function proxyChatApiRequest(event: H3Event, targetPath: string): Promise<any>;
+export declare function defineChatApiProxyHandler(resolveTargetPath: (path: string) => string): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;

package/dist/runtime/server/utils/chat-api-proxy.js

@@ -0,0 +1,108 @@
+import { createError, defineEventHandler, getHeader, getRequestURL, getRouterParam, proxyRequest } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+import { resolveAuthToken } from "./auth-token.js";
+const CHAT_COMPAT_HEADERS = [
+  "x-chat-workspace-id",
+  "x-chat-tela-agent-id",
+  "x-chat-conversation-scope"
+];
+function normalizeProxyPath(path) {
+  const segments = path.split("/").map((segment) => segment.trim()).filter(Boolean);
+  for (const segment of segments) {
+    let decodedSegment = "";
+    try {
+      decodedSegment = decodeURIComponent(segment);
+    } catch {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Invalid proxy path"
+      });
+    }
+    if (decodedSegment === "." || decodedSegment === ".." || decodedSegment.includes("/") || decodedSegment.includes("\\")) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Invalid proxy path"
+      });
+    }
+  }
+  return segments.join("/");
+}
+function joinProxyPath(...parts) {
+  return normalizeProxyPath(parts.join("/"));
+}
+function resolveChatApiUrl(event) {
+  const config = useRuntimeConfig(event);
+  const chatApiUrl = config.chatApiUrl || config.chatNuxt?.chatApiUrl || "";
+  if (!chatApiUrl) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "CHAT_API_URL is not configured"
+    });
+  }
+  return chatApiUrl;
+}
+function buildTargetUrl(event, targetPath) {
+  const base = new URL(resolveChatApiUrl(event));
+  const basePath = normalizeProxyPath(base.pathname);
+  const chatBasePath = basePath.endsWith("v1/chat") ? basePath : basePath.endsWith("v1") ? joinProxyPath(basePath, "chat") : joinProxyPath(basePath, "v1/chat");
+  base.pathname = `/${joinProxyPath(chatBasePath, targetPath)}`;
+  base.search = getRequestURL(event).search;
+  return base.toString();
+}
+function buildProxyHeaders(event) {
+  const token = resolveAuthToken(event);
+  if (!token) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Authentication token is required"
+    });
+  }
+  const headers = {
+    authorization: `Bearer ${token}`
+  };
+  for (const headerName of CHAT_COMPAT_HEADERS) {
+    const value = getHeader(event, headerName)?.trim();
+    if (value) {
+      headers[headerName] = value;
+    }
+  }
+  return headers;
+}
+export function mapVaultProxyPath(path) {
+  const normalizedPath = normalizeProxyPath(path);
+  if (normalizedPath === "permalink-metadata") {
+    return "files/metadata";
+  }
+  return joinProxyPath("files", normalizedPath);
+}
+export function mapWorkspaceProxyPath(path) {
+  const normalizedPath = normalizeProxyPath(path);
+  if (normalizedPath === "settings") {
+    return "settings";
+  }
+  if (normalizedPath === "usage") {
+    return "workspace/usage";
+  }
+  if (normalizedPath === "credentials" || normalizedPath.startsWith("credentials/")) {
+    return normalizedPath;
+  }
+  return joinProxyPath("workspace", normalizedPath);
+}
+export function prefixProxyPath(prefix, path) {
+  return joinProxyPath(prefix, path);
+}
+export async function proxyChatApiRequest(event, targetPath) {
+  return proxyRequest(event, buildTargetUrl(event, targetPath), {
+    fetchOptions: {
+      redirect: "manual"
+    },
+    headers: buildProxyHeaders(event),
+    streamRequest: true
+  });
+}
+export function defineChatApiProxyHandler(resolveTargetPath) {
+  return defineEventHandler((event) => {
+    const path = getRouterParam(event, "path") || "";
+    return proxyChatApiRequest(event, resolveTargetPath(path));
+  });
+}

package/dist/runtime/server/utils/domain-allow.d.ts

@@ -0,0 +1,2 @@
+export declare function parseAllowedEmailDomains(raw: string | null | undefined): string[];
+export declare function isEmailDomainAllowed(email: string | null | undefined, allowedDomains: string[]): boolean;

package/dist/runtime/server/utils/domain-allow.js

@@ -0,0 +1,11 @@
+export function parseAllowedEmailDomains(raw) {
+  if (!raw)
+    return [];
+  return raw.split(",").map((domain) => domain.trim().toLowerCase().replace(/^@/, "")).filter(Boolean);
+}
+export function isEmailDomainAllowed(email, allowedDomains) {
+  if (allowedDomains.length === 0)
+    return true;
+  const emailDomain = email?.split("@")[1]?.toLowerCase();
+  return !!emailDomain && allowedDomains.includes(emailDomain);
+}

package/dist/runtime/shared/chat-api-error.d.ts

@@ -0,0 +1 @@
+export declare function getChatApiErrorMessage(error: unknown): string | null;

package/dist/runtime/shared/chat-api-error.js

@@ -0,0 +1,12 @@
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringField(source, field) {
+  const value = source?.[field];
+  return typeof value === "string" && value ? value : null;
+}
+export function getChatApiErrorMessage(error) {
+  const root = isRecord(error) ? error : null;
+  const data = root && isRecord(root.data) ? root.data : null;
+  return stringField(data, "statusMessage") ?? stringField(data, "error") ?? stringField(data, "message") ?? stringField(root, "statusMessage") ?? stringField(root, "message");
+}

package/dist/runtime/shared/components/app-status-toast.vue

@@ -0,0 +1,43 @@
+<script setup>
+import { useStatusToast } from "../composables/status-toast";
+const statusToast = useStatusToast();
+</script>
+
+<template>
+    <Transition name="toast">
+        <div
+            v-if="statusToast.visible.value"
+            fixed
+            bottom-24px
+            left="50%"
+            translate-x="-50%"
+            z-1000
+            flex
+            items-center
+            gap-8px
+            px-16px
+            py-12px
+            bg-black-900
+            text-white
+            rounded-8px
+            shadow-lg
+        >
+            <span
+                v-if="statusToast.icon.value"
+                :class="statusToast.icon.value"
+                text-16px
+            />
+            <div
+                v-if="statusToast.loading.value"
+                i-ph-spinner
+                animate-spin
+                text-16px
+            />
+            <span body-14-regular>{{ statusToast.text.value }}</span>
+        </div>
+    </Transition>
+</template>
+
+<style scoped>
+.toast-enter-active,.toast-leave-active{transition:all .3s ease}.toast-enter-from,.toast-leave-to{opacity:0;transform:translateX(-50%) translateY(20px)}
+</style>

package/dist/runtime/shared/components/icons/tela-chat.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/shared/components/icons/tela-chat.vue

@@ -0,0 +1,6 @@
+<template>
+    <svg viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+        <rect width="16" height="16" rx="2" fill="currentColor" />
+        <path d="M3.7 4.15C3.7 3.79 3.99 3.5 4.35 3.5H11.65C12.01 3.5 12.3 3.79 12.3 4.15V10.35C12.3 10.71 12.01 11 11.65 11H8.75L5.85 13.45V11H4.35C3.99 11 3.7 10.71 3.7 10.35V4.15Z" fill="white" />
+    </svg>
+</template>

package/dist/runtime/shared/components/icons/tela-chat.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/shared/components/icons/tela-wordmark.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/shared/components/icons/tela-wordmark.vue

@@ -0,0 +1,9 @@
+<template>
+    <svg viewBox="0 0 38 12" fill="none" xmlns="http://www.w3.org/2000/svg">
+        <path d="M36.2775 6.40644C36.2775 5.46937 35.6276 4.89503 34.6301 4.89503C33.7081 4.89503 33.0582 5.43914 32.9524 6.34599L31.4712 6.07393C31.7131 4.57763 33.0129 3.59521 34.6301 3.59521C36.5647 3.59521 37.8947 4.68343 37.8947 6.58781V11.3337H36.2775V10.1699C35.8392 10.9407 34.9021 11.4546 33.8895 11.4546C32.3781 11.4546 31.3352 10.5024 31.3352 9.20256C31.3352 7.70626 32.499 6.90521 34.8417 6.66338L36.2775 6.51224V6.40644ZM32.9524 9.15721C32.9524 9.76178 33.4512 10.185 34.222 10.185C35.5067 10.185 36.2624 9.29324 36.2775 8.05388V7.73649L34.8266 7.90274C33.5872 8.03877 32.9524 8.49219 32.9524 9.15721Z" fill="currentColor" />
+        <path d="M28.5046 11.3331V0.632324H30.152V11.3331H28.5046Z" fill="currentColor" />
+        <path d="M20.1277 7.5244C20.1277 5.46888 21.3927 3.59473 23.7463 3.59473C26.1293 3.59473 27.3944 5.37819 27.3944 7.23723C27.3944 7.46394 27.3796 7.78134 27.3649 7.91737H21.7016C21.8487 9.2323 22.6725 10.0485 23.8493 10.0485C24.8201 10.0485 25.5115 9.57992 25.7027 8.74865L27.2178 9.14161C26.8207 10.6077 25.5556 11.4541 23.8199 11.4541C21.4663 11.4541 20.1277 9.57992 20.1277 7.5244ZM21.7752 6.6629H25.688C25.585 5.63513 24.9231 4.89454 23.7463 4.89454C22.7313 4.89454 22.0105 5.52934 21.7752 6.6629Z" fill="currentColor" />
+        <path d="M19.6861 11.2729C19.3234 11.3938 18.9002 11.4543 18.477 11.4543C17.0412 11.4543 15.9681 10.6684 15.9681 8.93023V5.12147H14.638V3.71585H15.9681V1.44873H17.6155V3.71585H19.5803V5.12147H17.6155V8.83954C17.6155 9.59525 18.0387 9.98822 18.6584 9.98822C18.9455 9.98822 19.2932 9.94287 19.5803 9.80685L19.6861 11.2729Z" fill="currentColor" />
+        <path fill-rule="evenodd" clip-rule="evenodd" d="M12 0H0V12H12V0ZM10.2512 1.74939H1.75122V10.2494H10.2512V1.74939Z" fill="currentColor" />
+    </svg>
+</template>

package/dist/runtime/shared/components/icons/tela-wordmark.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/shared/composables/chat-api.js

@@ -0,0 +1,39 @@
+import { useChatAuth } from "#chat-auth";
+import { useChatRequestContext } from "./chat-request-context.js";
+export function useChatApi() {
+  const requestContext = useChatRequestContext();
+  const { activeOrganization } = useChatAuth();
+  function buildHeaders(headers) {
+    const mergedHeaders = {
+      ...headers ?? {}
+    };
+    const workspaceId = requestContext?.workspaceId.value.trim() || activeOrganization.value?.id?.trim();
+    if (workspaceId) {
+      mergedHeaders["x-chat-workspace-id"] = workspaceId;
+    }
+    const telaAgentId = requestContext?.telaAgentId.value?.trim();
+    if (telaAgentId) {
+      mergedHeaders["x-chat-tela-agent-id"] = telaAgentId;
+    }
+    const conversationScope = requestContext?.conversationScope.value?.trim();
+    if (conversationScope) {
+      mergedHeaders["x-chat-conversation-scope"] = conversationScope;
+    }
+    return Object.keys(mergedHeaders).length > 0 ? mergedHeaders : void 0;
+  }
+  function withChatHeaders(options) {
+    const headers = buildHeaders(options?.headers);
+    const baseOptions = options ?? {};
+    return {
+      ...baseOptions,
+      ...headers ? { headers } : {}
+    };
+  }
+  function path(routePath) {
+    return `/api/chat${routePath}`;
+  }
+  return {
+    path,
+    withChatHeaders
+  };
+}

package/dist/runtime/shared/composables/chat-request-context.d.ts

@@ -0,0 +1,17 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+export type ChatRequestContext = {
+    workspaceId: Ref<string>;
+    telaAgentId: Ref<string | null>;
+    conversationScope: Ref<string | null>;
+};
+type ChatRequestContextInput = {
+    workspaceId: MaybeRefOrGetter<string | null | undefined>;
+    telaAgentId?: MaybeRefOrGetter<string | null | undefined>;
+    conversationScope?: MaybeRefOrGetter<string | null | undefined>;
+};
+type ProvideChatRequestContextOptions = {
+    syncGlobal?: boolean;
+};
+export declare function provideChatRequestContext(input: ChatRequestContextInput, options?: ProvideChatRequestContextOptions): void;
+export declare function useChatRequestContext(): ChatRequestContext | null;
+export {};

package/dist/runtime/shared/composables/chat-request-context.js

@@ -0,0 +1,43 @@
+const CHAT_REQUEST_CONTEXT_KEY = "chat-request-context";
+function normalizeOptionalHeaderValue(value) {
+  const trimmed = value?.trim();
+  return trimmed || null;
+}
+function useGlobalChatRequestContextState() {
+  return {
+    provided: useState("chat-request-context-provided", () => false),
+    workspaceId: useState("chat-request-context-workspace-id", () => ""),
+    telaAgentId: useState("chat-request-context-tela-agent-id", () => null),
+    conversationScope: useState("chat-request-context-conversation-scope", () => null)
+  };
+}
+export function provideChatRequestContext(input, options = {}) {
+  const context = {
+    workspaceId: computed(() => normalizeOptionalHeaderValue(toValue(input.workspaceId)) ?? ""),
+    telaAgentId: computed(() => normalizeOptionalHeaderValue(toValue(input.telaAgentId))),
+    conversationScope: computed(() => normalizeOptionalHeaderValue(toValue(input.conversationScope)))
+  };
+  const globalContext = useGlobalChatRequestContextState();
+  if (options.syncGlobal ?? true) {
+    watchEffect(() => {
+      globalContext.provided.value = true;
+      globalContext.workspaceId.value = context.workspaceId.value;
+      globalContext.telaAgentId.value = context.telaAgentId.value;
+      globalContext.conversationScope.value = context.conversationScope.value;
+    });
+  }
+  provide(CHAT_REQUEST_CONTEXT_KEY, context);
+}
+export function useChatRequestContext() {
+  const injectedContext = inject(CHAT_REQUEST_CONTEXT_KEY, null);
+  if (injectedContext)
+    return injectedContext;
+  const globalContext = useGlobalChatRequestContextState();
+  if (!globalContext.provided.value)
+    return null;
+  return {
+    workspaceId: computed(() => globalContext.workspaceId.value),
+    telaAgentId: computed(() => globalContext.telaAgentId.value),
+    conversationScope: computed(() => globalContext.conversationScope.value)
+  };
+}

package/dist/runtime/shared/composables/polling.d.ts

@@ -0,0 +1,12 @@
+export declare function usePolling({ callback, interval, stopCondition, onFinish, }: {
+    callback: () => Promise<void>;
+    interval: MaybeRef<number>;
+    stopCondition: Ref<boolean>;
+    onFinish?: () => void;
+}): {
+    isPolling: Readonly<import("@vue/reactivity").ShallowRef<boolean>>;
+    stop: () => void;
+    start: () => void;
+    resume: import("@vueuse/core").Fn;
+    waitForResult: () => Promise<void>;
+};

package/dist/runtime/shared/composables/verb-conjugation.d.ts

@@ -0,0 +1,7 @@
+export declare function useVerbConjugation(): {
+    conjugateText: (text: string, wasExecuted: boolean) => string;
+    isEnglish: (text: string) => boolean;
+    translateEnglishText: (text: string, toPast: boolean) => string;
+    conjugatePortugueseVerb: (text: string) => string;
+    resolveReadFileStepTitle: (fileName: string, wasExecuted: boolean) => string | null;
+};

package/dist/runtime/shared/composables/verb-conjugation.js

@@ -0,0 +1,269 @@
+const pt = {
+  buscar: { infinitive: "buscar", gerund: "Buscando", past: "Buscou" },
+  listar: { infinitive: "listar", gerund: "Listando", past: "Listou" },
+  encontrar: { infinitive: "encontrar", gerund: "Encontrando", past: "Encontrou" },
+  ler: { infinitive: "ler", gerund: "Lendo", past: "Leu" },
+  escrever: { infinitive: "escrever", gerund: "Escrevendo", past: "Escreveu" },
+  criar: { infinitive: "criar", gerund: "Criando", past: "Criou" },
+  deletar: { infinitive: "deletar", gerund: "Deletando", past: "Deletou" },
+  remover: { infinitive: "remover", gerund: "Removendo", past: "Removeu" },
+  copiar: { infinitive: "copiar", gerund: "Copiando", past: "Copiou" },
+  mover: { infinitive: "mover", gerund: "Movendo", past: "Moveu" },
+  executar: { infinitive: "executar", gerund: "Executando", past: "Executou" },
+  verificar: { infinitive: "verificar", gerund: "Verificando", past: "Verificou" },
+  instalar: { infinitive: "instalar", gerund: "Instalando", past: "Instalou" },
+  atualizar: { infinitive: "atualizar", gerund: "Atualizando", past: "Atualizou" },
+  construir: { infinitive: "construir", gerund: "Construindo", past: "Construiu" },
+  compilar: { infinitive: "compilar", gerund: "Compilando", past: "Compilou" },
+  testar: { infinitive: "testar", gerund: "Testando", past: "Testou" },
+  iniciar: { infinitive: "iniciar", gerund: "Iniciando", past: "Iniciou" },
+  parar: { infinitive: "parar", gerund: "Parando", past: "Parou" },
+  reiniciar: { infinitive: "reiniciar", gerund: "Reiniciando", past: "Reiniciou" },
+  carregar: { infinitive: "carregar", gerund: "Carregando", past: "Carregou" },
+  salvar: { infinitive: "salvar", gerund: "Salvando", past: "Salvou" },
+  baixar: { infinitive: "baixar", gerund: "Baixando", past: "Baixou" },
+  enviar: { infinitive: "enviar", gerund: "Enviando", past: "Enviou" },
+  analisar: { infinitive: "analisar", gerund: "Analisando", past: "Analisou" },
+  processar: { infinitive: "processar", gerund: "Processando", past: "Processou" },
+  obter: { infinitive: "obter", gerund: "Obtendo", past: "Obteve" },
+  definir: { infinitive: "definir", gerund: "Definindo", past: "Definiu" },
+  abrir: { infinitive: "abrir", gerund: "Abrindo", past: "Abriu" },
+  fechar: { infinitive: "fechar", gerund: "Fechando", past: "Fechou" },
+  escanear: { infinitive: "escanear", gerund: "Escaneando", past: "Escaneou" },
+  monitorar: { infinitive: "monitorar", gerund: "Monitorando", past: "Monitorou" },
+  aguardar: { infinitive: "aguardar", gerund: "Aguardando", past: "Aguardou" },
+  procurar: { infinitive: "procurar", gerund: "Procurando", past: "Procurou" },
+  explorar: { infinitive: "explorar", gerund: "Explorando", past: "Explorou" },
+  modificar: { infinitive: "modificar", gerund: "Modificando", past: "Modificou" },
+  alterar: { infinitive: "alterar", gerund: "Alterando", past: "Alterou" },
+  adicionar: { infinitive: "adicionar", gerund: "Adicionando", past: "Adicionou" },
+  renomear: { infinitive: "renomear", gerund: "Renomeando", past: "Renomeou" },
+  configurar: { infinitive: "configurar", gerund: "Configurando", past: "Configurou" },
+  preparar: { infinitive: "preparar", gerund: "Preparando", past: "Preparou" },
+  exibir: { infinitive: "exibir", gerund: "Exibindo", past: "Exibiu" },
+  limpar: { infinitive: "limpar", gerund: "Limpando", past: "Limpou" },
+  filtrar: { infinitive: "filtrar", gerund: "Filtrando", past: "Filtrou" },
+  ordenar: { infinitive: "ordenar", gerund: "Ordenando", past: "Ordenou" },
+  contar: { infinitive: "contar", gerund: "Contando", past: "Contou" },
+  comparar: { infinitive: "comparar", gerund: "Comparando", past: "Comparou" },
+  extrair: { infinitive: "extrair", gerund: "Extraindo", past: "Extraiu" },
+  comprimir: { infinitive: "comprimir", gerund: "Comprimindo", past: "Comprimiu" },
+  descomprimir: { infinitive: "descomprimir", gerund: "Descomprimindo", past: "Descomprimiu" },
+  consultar: { infinitive: "consultar", gerund: "Consultando", past: "Consultou" },
+  navegar: { infinitive: "navegar", gerund: "Navegando", past: "Navegou" },
+  trocar: { infinitive: "trocar", gerund: "Trocando", past: "Trocou" },
+  gerenciar: { infinitive: "gerenciar", gerund: "Gerenciando", past: "Gerenciou" },
+  apagar: { infinitive: "apagar", gerund: "Apagando", past: "Apagou" },
+  rodar: { infinitive: "rodar", gerund: "Rodando", past: "Rodou" },
+  subir: { infinitive: "subir", gerund: "Subindo", past: "Subiu" },
+  fazer: { infinitive: "fazer", gerund: "Fazendo", past: "Fez" }
+};
+function verb(key) {
+  return pt[key];
+}
+const englishToPortuguese = {
+  search: verb("buscar"),
+  searching: verb("buscar"),
+  list: verb("listar"),
+  listing: verb("listar"),
+  find: verb("encontrar"),
+  finding: verb("encontrar"),
+  read: verb("ler"),
+  reading: verb("ler"),
+  write: verb("escrever"),
+  writing: verb("escrever"),
+  create: verb("criar"),
+  creating: verb("criar"),
+  delete: verb("deletar"),
+  deleting: verb("deletar"),
+  remove: verb("remover"),
+  removing: verb("remover"),
+  copy: verb("copiar"),
+  copying: verb("copiar"),
+  move: verb("mover"),
+  moving: verb("mover"),
+  execute: verb("executar"),
+  executing: verb("executar"),
+  run: verb("executar"),
+  running: verb("executar"),
+  check: verb("verificar"),
+  checking: verb("verificar"),
+  verify: verb("verificar"),
+  verifying: verb("verificar"),
+  install: verb("instalar"),
+  installing: verb("instalar"),
+  update: verb("atualizar"),
+  updating: verb("atualizar"),
+  build: verb("construir"),
+  building: verb("construir"),
+  compile: verb("compilar"),
+  compiling: verb("compilar"),
+  test: verb("testar"),
+  testing: verb("testar"),
+  start: verb("iniciar"),
+  starting: verb("iniciar"),
+  stop: verb("parar"),
+  stopping: verb("parar"),
+  restart: verb("reiniciar"),
+  restarting: verb("reiniciar"),
+  load: verb("carregar"),
+  loading: verb("carregar"),
+  save: verb("salvar"),
+  saving: verb("salvar"),
+  download: verb("baixar"),
+  downloading: verb("baixar"),
+  upload: verb("enviar"),
+  uploading: verb("enviar"),
+  analyze: verb("analisar"),
+  analyzing: verb("analisar"),
+  process: verb("processar"),
+  processing: verb("processar"),
+  parse: verb("processar"),
+  parsing: verb("processar"),
+  fetch: verb("buscar"),
+  fetching: verb("buscar"),
+  get: verb("obter"),
+  getting: verb("obter"),
+  set: verb("definir"),
+  setting: verb("definir"),
+  open: verb("abrir"),
+  opening: verb("abrir"),
+  close: verb("fechar"),
+  closing: verb("fechar"),
+  scan: verb("escanear"),
+  scanning: verb("escanear"),
+  monitor: verb("monitorar"),
+  monitoring: verb("monitorar"),
+  wait: verb("aguardar"),
+  waiting: verb("aguardar"),
+  look: verb("procurar"),
+  looking: verb("procurar"),
+  navigate: verb("navegar"),
+  navigating: verb("navegar"),
+  explore: verb("explorar"),
+  exploring: verb("explorar"),
+  modify: verb("modificar"),
+  modifying: verb("modificar"),
+  change: verb("alterar"),
+  changing: verb("alterar"),
+  add: verb("adicionar"),
+  adding: verb("adicionar"),
+  rename: verb("renomear"),
+  renaming: verb("renomear"),
+  configure: verb("configurar"),
+  configuring: verb("configurar"),
+  prepare: verb("preparar"),
+  preparing: verb("preparar"),
+  display: verb("exibir"),
+  displaying: verb("exibir"),
+  show: verb("exibir"),
+  showing: verb("exibir"),
+  clean: verb("limpar"),
+  cleaning: verb("limpar"),
+  clear: verb("limpar"),
+  clearing: verb("limpar"),
+  match: verb("encontrar"),
+  matching: verb("encontrar"),
+  filter: verb("filtrar"),
+  filtering: verb("filtrar"),
+  sort: verb("ordenar"),
+  sorting: verb("ordenar"),
+  count: verb("contar"),
+  counting: verb("contar"),
+  compare: verb("comparar"),
+  comparing: verb("comparar"),
+  extract: verb("extrair"),
+  extracting: verb("extrair"),
+  compress: verb("comprimir"),
+  compressing: verb("comprimir"),
+  decompress: verb("descomprimir"),
+  decompressing: verb("descomprimir")
+};
+const ptValues = Object.values(pt);
+const gerundToPast = new Map(
+  ptValues.map((v) => [v.gerund, v.past])
+);
+const infinitiveToPast = new Map(
+  ptValues.map((v) => [v.infinitive, v.past])
+);
+const readFileStepLabels = {
+  "instructions.md": "instru\xE7\xF5es",
+  "output-format.json": "estrutura de sa\xEDda esperada",
+  "input-list.json": "lista de arquivos de entrada",
+  "result.json": "resultado"
+};
+export function useVerbConjugation() {
+  function isEnglish(text) {
+    const firstWord = text.trim().split(/\s+/)[0]?.toLowerCase() || "";
+    if (firstWord in englishToPortuguese) {
+      return true;
+    }
+    const englishPatterns = [
+      /^(search|list|find|read|write|create|delete|remove|copy|move|execute|run|check|verify)/i,
+      /\s(for|in|from|to|with|at|of|the|a|an)\s/i,
+      /files?|director(y|ies)|input|output|data/i
+    ];
+    return englishPatterns.some((pattern) => pattern.test(text));
+  }
+  function translateEnglishText(text, toPast) {
+    const words = text.trim().split(/\s+/);
+    const firstWord = words[0]?.toLowerCase();
+    if (!firstWord) {
+      return text;
+    }
+    if (firstWord in englishToPortuguese) {
+      const verb2 = englishToPortuguese[firstWord];
+      if (!verb2) {
+        return text;
+      }
+      const restOfSentence = words.slice(1).join(" ");
+      const translatedRest = restOfSentence.replace(/\bfor\b/gi, "por").replace(/\bin\b/gi, "em").replace(/\bfrom\b/gi, "de").replace(/\bto\b/gi, "para").replace(/\bwith\b/gi, "com").replace(/\bfiles?\b/gi, "arquivos").replace(/\bdirector(y|ies)\b/gi, (_match, suffix) => suffix === "ies" ? "diret\xF3rios" : "diret\xF3rio").replace(/\binput\b/gi, "entrada").replace(/\boutput\b/gi, "sa\xEDda").replace(/\bdata\b/gi, "dados");
+      const conjugatedVerb = toPast ? verb2.past : verb2.gerund;
+      return translatedRest ? `${conjugatedVerb} ${translatedRest}` : conjugatedVerb;
+    }
+    return text;
+  }
+  function conjugatePortugueseVerb(text) {
+    for (const [gerund, past] of gerundToPast) {
+      if (text.startsWith(gerund)) {
+        return text.replace(gerund, past);
+      }
+    }
+    for (const [infinitive, past] of infinitiveToPast) {
+      const regex = new RegExp(`^${infinitive}(\\s|$)`, "i");
+      if (regex.test(text)) {
+        return text.replace(regex, `${past}$1`);
+      }
+    }
+    let result = text;
+    result = result.replace(/^(\w)(\w*)ando(\s|$)/i, (_, first, rest, space) => `${first.toUpperCase()}${rest}ou${space}`);
+    result = result.replace(/^(\w)(\w*)endo(\s|$)/i, (_, first, rest, space) => `${first.toUpperCase()}${rest}eu${space}`);
+    result = result.replace(/^(\w)(\w*)indo(\s|$)/i, (_, first, rest, space) => `${first.toUpperCase()}${rest}iu${space}`);
+    result = result.replace(/^(\w)(\w*)ar(\s|$)/i, (_, first, rest, space) => `${first.toUpperCase()}${rest}ou${space}`);
+    result = result.replace(/^(\w)(\w*)er(\s|$)/i, (_, first, rest, space) => `${first.toUpperCase()}${rest}eu${space}`);
+    result = result.replace(/^(\w)(\w*)ir(\s|$)/i, (_, first, rest, space) => `${first.toUpperCase()}${rest}iu${space}`);
+    return result;
+  }
+  function conjugateText(text, wasExecuted) {
+    if (!wasExecuted) {
+      return text;
+    }
+    if (isEnglish(text)) {
+      return translateEnglishText(text, true);
+    }
+    return conjugatePortugueseVerb(text);
+  }
+  function resolveReadFileStepTitle(fileName, wasExecuted) {
+    const label = readFileStepLabels[fileName];
+    if (!label)
+      return null;
+    return conjugateText(`Lendo ${label}`, wasExecuted);
+  }
+  return {
+    conjugateText,
+    isEnglish,
+    translateEnglishText,
+    conjugatePortugueseVerb,
+    resolveReadFileStepTitle
+  };
+}

package/dist/runtime/shared/date-formatting.d.ts

@@ -0,0 +1,5 @@
+export declare function formatRelativeTime(dateInput: Date | string): string;
+export declare function formatAbsoluteDate(dateInput: Date | string): string;
+export declare function formatDateWithTime(date?: string | Date): string;
+export declare function formatShortDate(dateStr: string): string;
+export declare function formatTime(time: string): string;