ai-parrot 0.17.2__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

crew-builder/src/lib/stores/theme.svelte.js

@@ -0,0 +1,145 @@
+import { browser } from '$app/environment';
+
+/**
+ * Theme Store using Svelte 5 Runes
+ *
+ * Manages daisyUI theme switching with localStorage persistence.
+ * Based on: https://scottspence.com/posts/theme-switching-in-sveltekit-updated-for-daisyui-v5-and-tailwind-v4
+ */
+const STORAGE_KEY = 'theme';
+const DEFAULT_THEME = 'light';
+
+const THEMES = [
+  'light',
+  'dark',
+  'cupcake',
+  'bumblebee',
+  'emerald',
+  'corporate',
+  'synthwave',
+  'retro',
+  'cyberpunk',
+  'valentine',
+  'halloween',
+  'garden',
+  'forest',
+  'aqua',
+  'lofi',
+  'pastel',
+  'fantasy',
+  'wireframe',
+  'black',
+  'luxury',
+  'dracula',
+  'cmyk',
+  'autumn',
+  'business',
+  'acid',
+  'lemonade',
+  'night',
+  'coffee',
+  'winter',
+  'dim',
+  'nord',
+  'sunset'
+];
+
+class ThemeStore {
+  currentTheme = $state(DEFAULT_THEME);
+  availableThemes = THEMES;
+
+  /**
+   * Initialize the theme from localStorage or system preference
+   */
+  init() {
+    if (!browser) return;
+
+    // Try to get theme from localStorage
+    const stored = localStorage.getItem(STORAGE_KEY);
+
+    if (stored && THEMES.includes(stored)) {
+      this.setTheme(stored);
+    } else {
+      // Check for system dark mode preference
+      const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+      this.setTheme(prefersDark ? 'dark' : DEFAULT_THEME);
+    }
+
+    // Listen for system theme changes
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
+      if (!localStorage.getItem(STORAGE_KEY)) {
+        this.setTheme(e.matches ? 'dark' : DEFAULT_THEME);
+      }
+    });
+  }
+
+  /**
+   * Set the current theme
+   * @param {string} theme - Theme name
+   */
+  setTheme(theme) {
+    if (!THEMES.includes(theme)) {
+      console.warn(`Theme "${theme}" not found, using default`);
+      theme = DEFAULT_THEME;
+    }
+
+    this.currentTheme = theme;
+
+    if (browser) {
+      // Apply theme to document
+      document.documentElement.setAttribute('data-theme', theme);
+
+      // Save to localStorage
+      localStorage.setItem(STORAGE_KEY, theme);
+    }
+  }
+
+  /**
+   * Toggle between light and dark themes
+   */
+  toggleDarkMode() {
+    const newTheme = this.currentTheme === 'dark' ? 'light' : 'dark';
+    this.setTheme(newTheme);
+  }
+
+  /**
+   * Get the next theme in the list (for cycling through themes)
+   * @returns {string}
+   */
+  getNextTheme() {
+    const currentIndex = THEMES.indexOf(this.currentTheme);
+    const nextIndex = (currentIndex + 1) % THEMES.length;
+    return THEMES[nextIndex];
+  }
+
+  /**
+   * Cycle to the next theme
+   */
+  cycleTheme() {
+    const nextTheme = this.getNextTheme();
+    this.setTheme(nextTheme);
+  }
+
+  /**
+   * Check if current theme is dark
+   * @returns {boolean}
+   */
+  isDark() {
+    return (
+      this.currentTheme === 'dark' ||
+      this.currentTheme === 'halloween' ||
+      this.currentTheme === 'forest' ||
+      this.currentTheme === 'black' ||
+      this.currentTheme === 'luxury' ||
+      this.currentTheme === 'dracula' ||
+      this.currentTheme === 'business' ||
+      this.currentTheme === 'night' ||
+      this.currentTheme === 'coffee' ||
+      this.currentTheme === 'dim' ||
+      this.currentTheme === 'sunset'
+    );
+  }
+}
+
+export const themeStore = new ThemeStore();
+export { THEMES };

crew-builder/src/lib/stores/toast.svelte.ts

@@ -0,0 +1,69 @@
+import { browser } from '$app/environment';
+
+export type ToastType = 'info' | 'success' | 'warning' | 'error';
+
+export interface Toast {
+  id: string;
+  message: string;
+  type: ToastType;
+  duration: number;
+  dismissible: boolean;
+}
+
+class ToastStore {
+  toasts = $state<Toast[]>([]);
+
+  private generateId(): string {
+    return `toast-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  add(message: string, type: ToastType = 'info', duration: number = 5000, dismissible: boolean = true) {
+    if (!browser) return;
+
+    const id = this.generateId();
+    const toast: Toast = {
+      id,
+      message,
+      type,
+      duration,
+      dismissible
+    };
+
+    this.toasts = [...this.toasts, toast];
+
+    if (duration > 0) {
+      setTimeout(() => {
+        this.remove(id);
+      }, duration);
+    }
+
+    return id;
+  }
+
+  remove(id: string) {
+    this.toasts = this.toasts.filter((t) => t.id !== id);
+  }
+
+  clear() {
+    this.toasts = [];
+  }
+
+  // Convenience methods
+  info(message: string, duration?: number) {
+    return this.add(message, 'info', duration);
+  }
+
+  success(message: string, duration?: number) {
+    return this.add(message, 'success', duration);
+  }
+
+  warning(message: string, duration?: number) {
+    return this.add(message, 'warning', duration);
+  }
+
+  error(message: string, duration?: number) {
+    return this.add(message, 'error', duration);
+  }
+}
+
+export const toastStore = new ToastStore();

crew-builder/src/lib/utils/conversation.ts

@@ -0,0 +1,39 @@
+import type { ChatResponse } from '$lib/api/chat';
+import { config } from '$lib/config';
+
+const STORAGE_PREFIX = config.conversationStoragePrefix;
+
+type ConversationPayload = {
+  turns: Record<string, ChatResponse>;
+  order: string[];
+};
+
+function getKey(agentId: string) {
+  return `${STORAGE_PREFIX}.${agentId}`;
+}
+
+export function saveTurn(agentId: string, turn: ChatResponse) {
+  if (typeof window === 'undefined') return;
+  const raw = localStorage.getItem(getKey(agentId));
+  const payload: ConversationPayload = raw ? JSON.parse(raw) : { turns: {}, order: [] };
+  payload.turns[turn.turn_id] = turn;
+  if (!payload.order.includes(turn.turn_id)) {
+    payload.order.push(turn.turn_id);
+  }
+  localStorage.setItem(getKey(agentId), JSON.stringify(payload));
+}
+
+export function getTurn(agentId: string, turnId: string) {
+  if (typeof window === 'undefined') return null;
+  const raw = localStorage.getItem(getKey(agentId));
+  if (!raw) return null;
+  const payload: ConversationPayload = JSON.parse(raw);
+  return payload.turns[turnId] || null;
+}
+
+export function loadConversation(agentId: string) {
+  if (typeof window === 'undefined') return { turns: {}, order: [] };
+  const raw = localStorage.getItem(getKey(agentId));
+  if (!raw) return { turns: {}, order: [] };
+  return JSON.parse(raw) as ConversationPayload;
+}

crew-builder/src/lib/utils/markdown.ts

@@ -0,0 +1,122 @@
+const HEADING_REGEX = /^(#{1,6})\s+(.*)$/;
+const LIST_ITEM_REGEX = /^\s*[-*+]\s+(.*)$/;
+const CODE_BLOCK_REGEX = /^```/;
+
+function escapeHtml(value: string): string {
+  return value
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function renderInlineMarkdown(value: string): string {
+  let result = escapeHtml(value);
+
+  // Links [text](url)
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url) => {
+    const safeUrl = url.trim();
+    const safeText = text.trim().length ? text.trim() : safeUrl;
+    return `<a href="${safeUrl}" target="_blank" rel="noopener noreferrer">${safeText}</a>`;
+  });
+
+  // Bold **text** or __text__
+  result = result.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+  result = result.replace(/__([^_]+)__/g, '<strong>$1</strong>');
+
+  // Italic *text* or _text_
+  result = result.replace(/(^|[^*])\*([^*]+)\*(?!\*)/g, '$1<em>$2</em>');
+  result = result.replace(/(^|[^_])_([^_]+)_(?!_)/g, '$1<em>$2</em>');
+
+  // Inline code `code`
+  result = result.replace(/`([^`]+)`/g, '<code>$1</code>');
+
+  return result;
+}
+
+function renderCodeBlock(lines: string[]): string {
+  const escaped = lines.map(escapeHtml).join('\n');
+  return `<pre><code>${escaped}\n</code></pre>`;
+}
+
+export function markdownToHtml(markdown: string): string {
+  if (!markdown?.trim()) {
+    return '';
+  }
+
+  const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+  const html: string[] = [];
+  let listItems: string[] = [];
+  let codeBlock: string[] | null = null;
+
+  const flushList = () => {
+    if (!listItems.length) return;
+    html.push('<ul>');
+    for (const item of listItems) {
+      html.push(`<li>${renderInlineMarkdown(item)}</li>`);
+    }
+    html.push('</ul>');
+    listItems = [];
+  };
+
+  const flushParagraph = (content: string) => {
+    if (!content.trim()) {
+      html.push('<br />');
+      return;
+    }
+    html.push(`<p>${renderInlineMarkdown(content)}</p>`);
+  };
+
+  for (const line of lines) {
+    if (CODE_BLOCK_REGEX.test(line.trim())) {
+      if (codeBlock) {
+        html.push(renderCodeBlock(codeBlock));
+        codeBlock = null;
+      } else {
+        flushList();
+        codeBlock = [];
+      }
+      continue;
+    }
+
+    if (codeBlock) {
+      codeBlock.push(line);
+      continue;
+    }
+
+    const headingMatch = line.match(HEADING_REGEX);
+    if (headingMatch) {
+      flushList();
+      const level = Math.min(headingMatch[1].length, 6);
+      const content = renderInlineMarkdown(headingMatch[2]);
+      html.push(`<h${level}>${content}</h${level}>`);
+      continue;
+    }
+
+    const listMatch = line.match(LIST_ITEM_REGEX);
+    if (listMatch) {
+      listItems.push(listMatch[1]);
+      continue;
+    }
+
+    flushList();
+
+    if (!line.trim()) {
+      html.push('<br />');
+      continue;
+    }
+
+    flushParagraph(line);
+  }
+
+  if (codeBlock) {
+    html.push(renderCodeBlock(codeBlock));
+  }
+
+  flushList();
+
+  return html.join('\n');
+}
+
+export default markdownToHtml;

crew-builder/src/lib/utils/talkHistory.ts

@@ -0,0 +1,47 @@
+import { config } from '$lib/config';
+
+export type QuestionHistoryEntry = {
+  turnId: string;
+  question: string;
+  timestamp: string;
+  mode: 'talk' | 'method';
+  methodName?: string;
+  outputMode?: string;
+  background?: boolean;
+};
+
+type HistoryPayload = {
+  entries: QuestionHistoryEntry[];
+};
+
+function getKey(agentId: string) {
+  return `${config.conversationStoragePrefix}.${agentId}.history`;
+}
+
+export function loadQuestionHistory(agentId: string): QuestionHistoryEntry[] {
+  if (typeof window === 'undefined') return [];
+  const raw = localStorage.getItem(getKey(agentId));
+  if (!raw) return [];
+  try {
+    const payload = JSON.parse(raw) as HistoryPayload;
+    return Array.isArray(payload.entries) ? payload.entries : [];
+  } catch (error) {
+    console.error('Failed to parse history', error);
+    return [];
+  }
+}
+
+export function saveQuestionHistory(agentId: string, entry: QuestionHistoryEntry) {
+  if (typeof window === 'undefined') return;
+  const existing = loadQuestionHistory(agentId);
+  const filtered = existing.filter((item) => item.turnId !== entry.turnId);
+  const updated: HistoryPayload = {
+    entries: [...filtered, entry]
+  };
+  localStorage.setItem(getKey(agentId), JSON.stringify(updated));
+}
+
+export function clearQuestionHistory(agentId: string) {
+  if (typeof window === 'undefined') return;
+  localStorage.removeItem(getKey(agentId));
+}

crew-builder/src/routes/+layout.svelte

@@ -0,0 +1,20 @@
+<script>
+  import { onMount } from 'svelte';
+  import { authStore } from '$lib/stores/auth.svelte.ts';
+  import { themeStore } from '$lib/stores/theme.svelte.js';
+  import Toast from '$lib/components/Toast.svelte';
+  import '../app.css';
+
+  // Initialize stores on mount
+  onMount(() => {
+    authStore.init();
+    themeStore.init(); // Initialize theme store
+  });
+</script>
+
+<div class="min-h-screen">
+  <slot />
+</div>
+
+<!-- Global toast notifications -->
+<Toast />