@meistrari/chat-nuxt 1.0.0

package/dist/runtime/composables/useStatusToast.d.ts

@@ -0,0 +1,22 @@
+type Action = {
+    label: string;
+    onClick: (event?: MouseEvent) => void;
+};
+export declare function useStatusToast(): {
+    update: (options: {
+        text: string;
+        loading?: boolean;
+        progress?: number;
+        timeout?: number | null;
+        icon?: string;
+        actions?: Action[];
+    }) => void;
+    clear: () => void;
+    text: any;
+    loading: any;
+    visible: any;
+    progress: any;
+    icon: any;
+    actions: any;
+};
+export {};

package/dist/runtime/composables/useStatusToast.js

@@ -0,0 +1,40 @@
+export function useStatusToast() {
+  const state = useState("status-toast-state", () => ({
+    text: "",
+    loading: false,
+    visible: false,
+    progress: null,
+    icon: null,
+    actions: []
+  }));
+  const lastTimeout = useState("status-toast-last-timeout", () => 0);
+  function update(options) {
+    if (state.value.visible)
+      window.clearTimeout(lastTimeout.value);
+    state.value.text = options.text;
+    state.value.loading = options.loading ?? false;
+    state.value.progress = options.progress ?? null;
+    state.value.icon = options.icon ?? null;
+    state.value.actions = options.actions ?? [];
+    if (typeof options.timeout === "number" && options.timeout > 0 || options.timeout === void 0) {
+      lastTimeout.value = window.setTimeout(clear, options.timeout ?? 2e3);
+    }
+    state.value.visible = true;
+  }
+  function clear() {
+    state.value.visible = false;
+    state.value.progress = null;
+    state.value.icon = null;
+    state.value.actions = [];
+  }
+  return {
+    update,
+    clear,
+    text: computed(() => state.value.text),
+    loading: computed(() => state.value.loading),
+    visible: computed(() => state.value.visible),
+    progress: computed(() => state.value.progress),
+    icon: computed(() => state.value.icon),
+    actions: computed(() => state.value.actions)
+  };
+}

package/dist/runtime/composables/useTela.d.ts

@@ -0,0 +1,12 @@
+export declare function useTela(): {
+    projects: any;
+    canvas: any;
+    workspaceStats: any;
+    workstations: any;
+    loading: any;
+    loadingWorkstations: any;
+    refreshProjects: any;
+    refreshCanvas: any;
+    refreshWorkspaceStats: any;
+    refreshAll: () => Promise<void>;
+};

package/dist/runtime/composables/useTela.js

@@ -0,0 +1,47 @@
+export function useTela() {
+  const { data: projects, status: projectsStatus, refresh: refreshProjects } = useAsyncData(
+    "tela-projects",
+    () => $fetch("/api/tela/projects"),
+    { default: () => [] }
+  );
+  const { data: canvas, status: canvasStatus, refresh: refreshCanvas } = useAsyncData(
+    "tela-canvas",
+    () => $fetch("/api/tela/canvas", {
+      params: { includePromotedVersion: "true" }
+    }),
+    { default: () => [] }
+  );
+  const { data: workspaceStats, status: workspaceStatus, refresh: refreshWorkspaceStats } = useAsyncData(
+    "tela-workspace-stats",
+    () => $fetch("/api/tela/workspaces"),
+    { default: () => null }
+  );
+  const { data: workstations, status: workstationsStatus } = useAsyncData(
+    "tela-workstations",
+    () => $fetch("/api/tela/workstations"),
+    { default: () => [] }
+  );
+  const loading = computed(
+    () => projectsStatus.value === "pending" || canvasStatus.value === "pending" || workspaceStatus.value === "pending" || workstationsStatus.value === "pending"
+  );
+  const loadingWorkstations = computed(() => workstationsStatus.value === "pending");
+  const refreshAll = async () => {
+    await Promise.all([
+      refreshProjects(),
+      refreshCanvas(),
+      refreshWorkspaceStats()
+    ]);
+  };
+  return {
+    projects,
+    canvas,
+    workspaceStats,
+    workstations,
+    loading,
+    loadingWorkstations,
+    refreshProjects,
+    refreshCanvas,
+    refreshWorkspaceStats,
+    refreshAll
+  };
+}

package/dist/runtime/composables/useToolFormatting.d.ts

@@ -0,0 +1,5 @@
+export declare function useToolFormatting(): {
+    formatToolName: (name: string) => string;
+    getDisplayName: (toolName: string) => string;
+    toolDisplayNames: Record<string, string>;
+};

package/dist/runtime/composables/useToolFormatting.js

@@ -0,0 +1,61 @@
+const toolDisplayNames = {
+  WebSearch: "Pesquisando na web",
+  Skill: "Executando skill",
+  Bash: "Executando comando",
+  Write: "Escrevendo arquivo",
+  Read: "Lendo arquivo",
+  Grep: "Buscando no c\xF3digo",
+  Glob: "Buscando arquivos",
+  Edit: "Editando arquivo",
+  Task: "Executando tarefa",
+  TodoWrite: "Atualizando tarefas",
+  Search: "Buscando",
+  CodebaseSearch: "Buscando no c\xF3digo",
+  FileSearch: "Buscando arquivos"
+};
+const translations = {
+  Search: "Busca",
+  Read: "Leitura",
+  Write: "Escrita",
+  Edit: "Edi\xE7\xE3o",
+  File: "Arquivo",
+  Directory: "Diret\xF3rio",
+  Code: "C\xF3digo",
+  Codebase: "C\xF3digo",
+  Web: "Web",
+  Bash: "Terminal",
+  Execute: "Execu\xE7\xE3o",
+  Run: "Execu\xE7\xE3o",
+  Task: "Tarefa",
+  Todo: "Tarefa",
+  Glob: "Busca",
+  Grep: "Busca",
+  Skill: "Skill"
+};
+const translationRegexes = Object.entries(translations).map(([en, pt]) => ({
+  regex: new RegExp(`\\b${en}\\b`, "gi"),
+  replacement: pt
+}));
+const toolNameCache = /* @__PURE__ */ new Map();
+export function useToolFormatting() {
+  function formatToolName(name) {
+    if (toolNameCache.has(name)) {
+      return toolNameCache.get(name);
+    }
+    let formatted = name.replace(/_/g, " ");
+    translationRegexes.forEach(({ regex, replacement }) => {
+      formatted = formatted.replace(regex, replacement);
+    });
+    formatted = formatted.replace(/\b\w/g, (c) => c.toUpperCase());
+    toolNameCache.set(name, formatted);
+    return formatted;
+  }
+  function getDisplayName(toolName) {
+    return toolDisplayNames[toolName] || formatToolName(toolName);
+  }
+  return {
+    formatToolName,
+    getDisplayName,
+    toolDisplayNames
+  };
+}

package/dist/runtime/composables/useVault.d.ts

@@ -0,0 +1,13 @@
+type VaultFileInfo = {
+    url: string;
+    originalFileName?: string;
+    mimeType?: string;
+};
+export declare function useVault(): {
+    loading: any;
+    error: any;
+    getFilePublicUrl: (reference: string) => Promise<string>;
+    getFileInfo: (reference: string) => Promise<VaultFileInfo>;
+    isVaultReference: (url: string) => boolean;
+};
+export {};

package/dist/runtime/composables/useVault.js

@@ -0,0 +1,35 @@
+export function useVault() {
+  const loading = ref(false);
+  const error = ref(null);
+  const getFileInfo = async (reference) => {
+    loading.value = true;
+    error.value = null;
+    try {
+      const result = await $fetch("/api/vault/resolve", {
+        method: "POST",
+        body: { reference }
+      });
+      return result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Falha ao resolver a refer\xEAncia do vault";
+      error.value = message;
+      throw err;
+    } finally {
+      loading.value = false;
+    }
+  };
+  const getFilePublicUrl = async (reference) => {
+    const info = await getFileInfo(reference);
+    return info.url;
+  };
+  const isVaultReference = (url) => {
+    return url.startsWith("vault://");
+  };
+  return {
+    loading: readonly(loading),
+    error: readonly(error),
+    getFilePublicUrl,
+    getFileInfo,
+    isVaultReference
+  };
+}

package/dist/runtime/composables/useVerbConjugation.d.ts

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

package/dist/runtime/composables/useVerbConjugation.js

@@ -0,0 +1,256 @@
+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])
+);
+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);
+  }
+  return {
+    conjugateText,
+    isEnglish,
+    translateEnglishText,
+    conjugatePortugueseVerb
+  };
+}

package/dist/runtime/composables/useWorkspaceContextFiles.d.ts

@@ -0,0 +1,19 @@
+import type { ContextFile } from '../server/db/schema.js';
+import type { WorkspaceSettings, WorkspaceSettingsUpdate } from './useWorkspaceSettings.js';
+export declare const MAX_FILES = 10;
+export declare const MAX_FILE_SIZE: number;
+export declare function useWorkspaceContextFiles(searchQuery: Ref<string>, currentContextFiles: Ref<readonly ContextFile[] | null | undefined> | ComputedRef<readonly ContextFile[] | null | undefined>, updateSettings: (updates: WorkspaceSettingsUpdate) => Promise<WorkspaceSettings>): {
+    pendingFiles: any;
+    filteredContextFiles: any;
+    filteredPendingFiles: any;
+    currentFileCount: any;
+    hasChanges: any;
+    maxFiles: number;
+    handleFileSelect: (event: Event) => void;
+    removePendingFile: (file: File) => void;
+    removeContextFile: (url: string) => Promise<void>;
+    getFileType: (fileName: string) => string;
+    initialize: () => void;
+    getPendingFiles: () => File[];
+    clearPendingFiles: () => void;
+};

package/dist/runtime/composables/useWorkspaceContextFiles.js

@@ -0,0 +1,74 @@
+export const MAX_FILES = 10;
+export const MAX_FILE_SIZE = 10 * 1024 * 1024;
+export function useWorkspaceContextFiles(searchQuery, currentContextFiles, updateSettings) {
+  const pendingFiles = ref([]);
+  const filteredContextFiles = computed(() => {
+    if (!currentContextFiles.value)
+      return [];
+    if (!searchQuery.value.trim())
+      return currentContextFiles.value;
+    const query = searchQuery.value.toLowerCase();
+    return currentContextFiles.value.filter(
+      (file) => file.name.toLowerCase().includes(query)
+    );
+  });
+  const filteredPendingFiles = computed(() => {
+    if (!searchQuery.value.trim())
+      return pendingFiles.value;
+    const query = searchQuery.value.toLowerCase();
+    return pendingFiles.value.filter(
+      (file) => file.name.toLowerCase().includes(query)
+    );
+  });
+  const currentFileCount = computed(
+    () => (currentContextFiles.value?.length ?? 0) + pendingFiles.value.length
+  );
+  const hasChanges = computed(
+    () => pendingFiles.value.length > 0
+  );
+  function handleFileSelect(event) {
+    const target = event.target;
+    if (!target.files)
+      return;
+    const newFiles = Array.from(target.files).filter((file) => file.size <= MAX_FILE_SIZE);
+    const availableSlots = MAX_FILES - currentFileCount.value;
+    pendingFiles.value = [...pendingFiles.value, ...newFiles.slice(0, availableSlots)];
+    target.value = "";
+  }
+  function removePendingFile(file) {
+    const idx = pendingFiles.value.indexOf(file);
+    if (idx !== -1)
+      pendingFiles.value = pendingFiles.value.filter((_, i) => i !== idx);
+  }
+  async function removeContextFile(url) {
+    const newFiles = (currentContextFiles.value ?? []).filter((f) => f.url !== url);
+    await updateSettings({ contextFiles: newFiles.length > 0 ? newFiles : null });
+  }
+  function getFileType(fileName) {
+    return fileName.split(".").pop()?.toUpperCase() ?? "";
+  }
+  function initialize() {
+    pendingFiles.value = [];
+  }
+  function getPendingFiles() {
+    return [...pendingFiles.value];
+  }
+  function clearPendingFiles() {
+    pendingFiles.value = [];
+  }
+  return {
+    pendingFiles: readonly(pendingFiles),
+    filteredContextFiles,
+    filteredPendingFiles,
+    currentFileCount,
+    hasChanges,
+    maxFiles: MAX_FILES,
+    handleFileSelect,
+    removePendingFile,
+    removeContextFile,
+    getFileType,
+    initialize,
+    getPendingFiles,
+    clearPendingFiles
+  };
+}

package/dist/runtime/composables/useWorkspaceCredentials.d.ts

@@ -0,0 +1,34 @@
+import type { WorkspaceCredential } from '../types/credential.js';
+export declare function useWorkspaceCredentials(searchQuery?: Ref<string>): {
+    credentials: any;
+    loading: any;
+    fetchCredentials: () => Promise<any>;
+    createCredential: (payload: {
+        key: string;
+        value: string;
+    }) => Promise<any>;
+    updateCredential: (id: string, payload: {
+        value: string;
+    }) => Promise<any>;
+    deleteCredential: (id: string) => Promise<void>;
+    filteredCredentials: any;
+    credentialModalOpen: any;
+    deleteModalOpen: any;
+    credentialForm: any;
+    credentialSaving: any;
+    credentialDeleting: any;
+    credentialError: any;
+    editingCredential: any;
+    deletingCredential: any;
+    openCreateModal: () => void;
+    openEditModal: (credential: WorkspaceCredential) => void;
+    closeModal: () => void;
+    handleSave: () => Promise<void>;
+    handleDelete: () => Promise<void>;
+    getMenuItems: (credential: WorkspaceCredential) => {
+        label: string;
+        icon: string;
+        click: () => void;
+    }[];
+    formatLastRotated: (updatedAt: string, createdAt: string) => string;
+};