prompt_objects 0.5.0 → 0.7.0

data/frontend/src/store/index.ts

@@ -1,279 +0,0 @@
-import { create } from 'zustand'
-import { useShallow } from 'zustand/react/shallow'
-import type {
-  PromptObject,
-  BusMessage,
-  Notification,
-  Environment,
-  Message,
-  LLMConfig,
-} from '../types'
-
-interface Store {
-  // Connection state
-  connected: boolean
-  setConnected: (connected: boolean) => void
-  resetOnDisconnect: () => void
-
-  // Environment
-  environment: Environment | null
-  setEnvironment: (env: Environment) => void
-
-  // Prompt Objects
-  promptObjects: Record<string, PromptObject>
-  setPromptObject: (name: string, state: Partial<PromptObject>) => void
-  removePromptObject: (name: string) => void
-  updatePromptObjectStatus: (name: string, status: PromptObject['status']) => void
-  addMessageToPO: (poName: string, message: Message) => void
-  updateSessionMessages: (poName: string, sessionId: string, messages: Message[]) => void
-  switchPOSession: (poName: string, sessionId: string) => void
-
-  // Navigation
-  selectedPO: string | null
-  selectPO: (name: string | null) => void
-  activeTab: 'chat' | 'sessions' | 'capabilities' | 'prompt'
-  setActiveTab: (tab: Store['activeTab']) => void
-  currentView: 'dashboard' | 'canvas'
-  setCurrentView: (view: Store['currentView']) => void
-
-  // Message Bus
-  busMessages: BusMessage[]
-  addBusMessage: (message: BusMessage) => void
-  busOpen: boolean
-  toggleBus: () => void
-  topPaneCollapsed: boolean
-  toggleTopPane: () => void
-
-  // Notifications
-  notifications: Notification[]
-  addNotification: (notification: Notification) => void
-  removeNotification: (id: string) => void
-
-  // Streaming
-  streamingContent: Record<string, string>
-  appendStreamChunk: (poName: string, chunk: string) => void
-  clearStream: (poName: string) => void
-
-  // Response handling
-  pendingResponse: Record<string, string>
-  setPendingResponse: (poName: string, content: string) => void
-  clearPendingResponse: (poName: string) => void
-
-  // LLM Config
-  llmConfig: LLMConfig | null
-  setLLMConfig: (config: LLMConfig) => void
-  updateCurrentLLM: (provider: string, model: string) => void
-
-  // Usage data (for modal display)
-  usageData: Record<string, unknown> | null
-  setUsageData: (data: Record<string, unknown>) => void
-  clearUsageData: () => void
-}
-
-export const useStore = create<Store>((set) => ({
-  // Connection
-  connected: false,
-  setConnected: (connected) => set({ connected }),
-  resetOnDisconnect: () =>
-    set((s) => {
-      // Reset all PO statuses to idle (server will re-send correct status on reconnect)
-      const resetPOs: Record<string, PromptObject> = {}
-      for (const [name, po] of Object.entries(s.promptObjects)) {
-        resetPOs[name] = po.status !== 'idle' ? { ...po, status: 'idle' } : po
-      }
-      return {
-        connected: false,
-        promptObjects: resetPOs,
-        streamingContent: {},   // Clear broken streams
-        pendingResponse: {},    // Clear stale pending responses
-      }
-    }),
-
-  // Environment
-  environment: null,
-  setEnvironment: (environment) => set({ environment }),
-
-  // Prompt Objects
-  promptObjects: {},
-  setPromptObject: (name, state) =>
-    set((s) => ({
-      promptObjects: {
-        ...s.promptObjects,
-        [name]: {
-          ...s.promptObjects[name],
-          ...state,
-          name, // Ensure name is always set
-        } as PromptObject,
-      },
-    })),
-  removePromptObject: (name) =>
-    set((s) => {
-      const { [name]: _, ...rest } = s.promptObjects
-      // If we're viewing this PO, deselect it
-      const selectedPO = s.selectedPO === name ? null : s.selectedPO
-      return { promptObjects: rest, selectedPO }
-    }),
-  updatePromptObjectStatus: (name, status) =>
-    set((s) => ({
-      promptObjects: {
-        ...s.promptObjects,
-        [name]: {
-          ...s.promptObjects[name],
-          status,
-        },
-      },
-    })),
-  addMessageToPO: (poName, message) =>
-    set((s) => {
-      const po = s.promptObjects[poName]
-      if (!po) return s
-
-      // Handle case where current_session doesn't exist yet (new POs)
-      const currentMessages = po.current_session?.messages || []
-      return {
-        promptObjects: {
-          ...s.promptObjects,
-          [poName]: {
-            ...po,
-            current_session: {
-              id: po.current_session?.id || 'pending',
-              messages: [...currentMessages, message],
-            },
-          },
-        },
-      }
-    }),
-  updateSessionMessages: (poName, sessionId, messages) =>
-    set((s) => {
-      const po = s.promptObjects[poName]
-      if (!po) return s
-
-      // Update current_session if it matches the sessionId, OR if current_session is null
-      // (handles newly created POs that didn't have session info yet)
-      if (po.current_session?.id === sessionId || !po.current_session) {
-        return {
-          promptObjects: {
-            ...s.promptObjects,
-            [poName]: {
-              ...po,
-              current_session: {
-                id: sessionId,
-                messages,
-              },
-            },
-          },
-        }
-      }
-
-      // Otherwise, just update the session in the sessions list (message count)
-      // The full messages will be loaded when the user switches to that session
-      return s
-    }),
-  switchPOSession: (poName, sessionId) =>
-    set((s) => {
-      const po = s.promptObjects[poName]
-      if (!po) return s
-
-      // Switch to a new session - clear messages until session_updated arrives
-      return {
-        promptObjects: {
-          ...s.promptObjects,
-          [poName]: {
-            ...po,
-            current_session: {
-              id: sessionId,
-              messages: [], // Will be populated by session_updated
-            },
-          },
-        },
-      }
-    }),
-
-  // Navigation
-  selectedPO: null,
-  selectPO: (name) => set({ selectedPO: name, activeTab: 'chat' }),
-  activeTab: 'chat',
-  setActiveTab: (activeTab) => set({ activeTab }),
-  currentView: 'dashboard',
-  setCurrentView: (currentView) => set({ currentView }),
-
-  // Message Bus
-  busMessages: [],
-  addBusMessage: (message) =>
-    set((s) => ({
-      busMessages: [...s.busMessages.slice(-99), message], // Keep last 100
-    })),
-  busOpen: false,
-  toggleBus: () => set((s) => ({ busOpen: !s.busOpen })),
-  topPaneCollapsed: false,
-  toggleTopPane: () => set((s) => ({ topPaneCollapsed: !s.topPaneCollapsed })),
-
-  // Notifications
-  notifications: [],
-  addNotification: (notification) =>
-    set((s) => ({
-      notifications: [...s.notifications, notification],
-    })),
-  removeNotification: (id) =>
-    set((s) => ({
-      notifications: s.notifications.filter((n) => n.id !== id),
-    })),
-
-  // Streaming
-  streamingContent: {},
-  appendStreamChunk: (poName, chunk) =>
-    set((s) => ({
-      streamingContent: {
-        ...s.streamingContent,
-        [poName]: (s.streamingContent[poName] || '') + chunk,
-      },
-    })),
-  clearStream: (poName) =>
-    set((s) => {
-      const { [poName]: _, ...rest } = s.streamingContent
-      return { streamingContent: rest }
-    }),
-
-  // Response handling
-  pendingResponse: {},
-  setPendingResponse: (poName, content) =>
-    set((s) => ({
-      pendingResponse: {
-        ...s.pendingResponse,
-        [poName]: content,
-      },
-    })),
-  clearPendingResponse: (poName) =>
-    set((s) => {
-      const { [poName]: _, ...rest } = s.pendingResponse
-      return { pendingResponse: rest }
-    }),
-
-  // LLM Config
-  llmConfig: null,
-  setLLMConfig: (config) => set({ llmConfig: config }),
-  updateCurrentLLM: (provider, model) =>
-    set((s) => ({
-      llmConfig: s.llmConfig
-        ? { ...s.llmConfig, current_provider: provider, current_model: model }
-        : null,
-    })),
-
-  // Usage data
-  usageData: null,
-  setUsageData: (data) => set({ usageData: data }),
-  clearUsageData: () => set({ usageData: null }),
-}))
-
-// Selectors - use useShallow to prevent infinite re-renders with derived arrays
-export const usePromptObjects = () =>
-  useStore(useShallow((s) => Object.values(s.promptObjects)))
-
-export const useSelectedPO = () =>
-  useStore((s) => (s.selectedPO ? s.promptObjects[s.selectedPO] : null))
-
-export const useNotificationCount = () =>
-  useStore((s) => s.notifications.length)
-
-export const usePONotifications = (poName: string) =>
-  useStore(useShallow((s) => s.notifications.filter((n) => n.po_name === poName)))

data/frontend/src/types/index.ts

@@ -1,165 +0,0 @@
-// Core types for PromptObjects frontend
-
-export interface Message {
-  role: 'user' | 'assistant' | 'tool'
-  content: string | null
-  from?: string
-  tool_calls?: ToolCall[]
-  results?: ToolResult[]
-}
-
-export interface ToolCall {
-  id: string
-  name: string
-  arguments: Record<string, unknown>
-}
-
-export interface ToolResult {
-  tool_call_id: string
-  name?: string  // Name of the tool that was called
-  content: string
-}
-
-export type ThreadType = 'root' | 'continuation' | 'delegation' | 'fork'
-
-export interface Session {
-  id: string
-  name: string | null
-  message_count: number
-  updated_at?: string
-  // Thread fields
-  parent_session_id?: string
-  parent_po?: string
-  thread_type: ThreadType
-}
-
-export interface ThreadTree {
-  session: Session
-  children: ThreadTree[]
-}
-
-export interface CurrentSession {
-  id: string
-  messages: Message[]
-}
-
-export interface CapabilityInfo {
-  name: string
-  description: string
-  parameters?: Record<string, unknown>
-}
-
-// Alias for backwards compatibility
-export type UniversalCapability = CapabilityInfo
-
-export interface PromptObject {
-  name: string
-  description: string
-  status: 'idle' | 'thinking' | 'calling_tool'
-  capabilities: CapabilityInfo[]
-  universal_capabilities?: CapabilityInfo[]
-  current_session: CurrentSession | null
-  sessions: Session[]
-  prompt?: string  // The markdown body/prompt
-  config?: Record<string, unknown>  // The YAML frontmatter config
-  delegated_by?: string | null  // Name of the PO that called this one (set by delegation events)
-}
-
-export interface BusMessage {
-  from: string
-  to: string
-  content: string | Record<string, unknown>
-  summary?: string
-  timestamp: string
-}
-
-export interface Notification {
-  id: string
-  po_name: string
-  type: string
-  message: string
-  options: string[]
-}
-
-export interface Environment {
-  name: string
-  path: string
-  po_count: number
-  primitive_count: number
-}
-
-// LLM Provider configuration
-export interface LLMProvider {
-  name: string
-  models: string[]
-  default_model: string
-  available: boolean
-}
-
-export interface LLMConfig {
-  current_provider: string
-  current_model: string
-  providers: LLMProvider[]
-}
-
-// WebSocket message types
-export type WSMessageType =
-  | 'environment'
-  | 'po_state'
-  | 'po_response'
-  | 'po_added'
-  | 'po_modified'
-  | 'po_removed'
-  | 'po_delegation_started'
-  | 'po_delegation_completed'
-  | 'stream'
-  | 'stream_end'
-  | 'bus_message'
-  | 'notification'
-  | 'notification_resolved'
-  | 'session_created'
-  | 'session_switched'
-  | 'session_updated'
-  | 'thread_created'
-  | 'thread_tree'
-  | 'llm_config'
-  | 'llm_switched'
-  | 'session_usage'
-  | 'thread_export'
-  | 'prompt_updated'
-  | 'llm_error'
-  | 'error'
-  | 'pong'
-
-export interface WSMessage<T = unknown> {
-  type: WSMessageType
-  payload: T
-}
-
-// Client -> Server message types
-export interface SendMessagePayload {
-  target: string
-  content: string
-  new_thread?: boolean  // If true, create a new thread before sending
-}
-
-export interface RespondToNotificationPayload {
-  id: string
-  response: string
-}
-
-export interface CreateSessionPayload {
-  target: string
-  name?: string
-}
-
-export interface SwitchSessionPayload {
-  target: string
-  session_id: string
-}
-
-export interface CreateThreadPayload {
-  target: string
-  name?: string
-  thread_type?: ThreadType
-}

data/frontend/tailwind.config.js

@@ -1,44 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-export default {
-  content: [
-    "./index.html",
-    "./src/**/*.{js,ts,jsx,tsx}",
-  ],
-  theme: {
-    extend: {
-      colors: {
-        po: {
-          bg: '#1a1918',
-          surface: '#222120',
-          'surface-2': '#2c2a28',
-          'surface-3': '#363432',
-          border: '#3d3a37',
-          'border-focus': '#5c5752',
-          accent: '#d4952a',
-          'accent-muted': '#9a6d20',
-          'accent-wash': 'rgba(212,149,42,0.08)',
-          'text-primary': '#e8e2da',
-          'text-secondary': '#a8a29a',
-          'text-tertiary': '#78726a',
-          'text-ghost': '#524e48',
-          'status-idle': '#78726a',
-          'status-active': '#d4952a',
-          'status-calling': '#3b9a6e',
-          'status-error': '#c45c4a',
-          'status-delegated': '#5a8fc2',
-          success: '#3b9a6e',
-          warning: '#d4952a',
-          error: '#c45c4a',
-        },
-      },
-      fontFamily: {
-        ui: ['Geist', 'system-ui', 'sans-serif'],
-        mono: ['"Geist Mono"', '"IBM Plex Mono"', 'monospace'],
-      },
-      fontSize: {
-        '2xs': ['11px', { lineHeight: '15px' }],
-      },
-    },
-  },
-  plugins: [],
-}

data/frontend/tsconfig.json

@@ -1,30 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true,
-
-    /* Paths */
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["src/*"]
-    }
-  },
-  "include": ["src"]
-}

data/frontend/vite.config.ts

@@ -1,29 +0,0 @@
-import { defineConfig } from 'vite'
-import react from '@vitejs/plugin-react'
-
-// https://vite.dev/config/
-export default defineConfig({
-  plugins: [react()],
-
-  // Output to Ruby server's public directory for production
-  build: {
-    outDir: '../lib/prompt_objects/server/public',
-    emptyOutDir: true,
-  },
-
-  // Development proxy to Ruby server
-  server: {
-    port: 5173,
-    proxy: {
-      '/api': {
-        target: 'http://localhost:3000',
-        changeOrigin: true,
-      },
-      // WebSocket proxy
-      '/ws': {
-        target: 'ws://localhost:3000',
-        ws: true,
-      },
-    },
-  },
-})