@simonyea/holysheep-cli 1.7.135 → 2.0.0

package/src/webui/workspace-store.js

@@ -0,0 +1,325 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const crypto = require('crypto')
+const { CONFIG_DIR } = require('../utils/config')
+
+const STATE_FILE = path.join(CONFIG_DIR, 'workspace-state.json')
+const STATE_VERSION = 1
+
+function now() {
+  return new Date().toISOString()
+}
+
+function createDefaultState() {
+  return {
+    version: STATE_VERSION,
+    updatedAt: now(),
+    holySheepApi: {
+      apiKey: '',
+      baseUrl: '',
+      model: '',
+    },
+    conversations: [],
+    scheduledTasks: [],
+  }
+}
+
+function ensureDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+}
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value))
+}
+
+function normalizeConversation(item = {}) {
+  const createdAt = item.createdAt || now()
+  const messages = Array.isArray(item.messages)
+    ? item.messages.map((message) => ({
+        id: message.id || crypto.randomUUID(),
+        role: message.role === 'assistant' ? 'assistant' : 'user',
+        content: String(message.content || ''),
+        status: message.status || 'done',
+        createdAt: message.createdAt || createdAt,
+        meta: typeof message.meta === 'object' && message.meta ? message.meta : {},
+      }))
+    : []
+
+  const lastMessage = messages[messages.length - 1] || null
+
+  return {
+    id: item.id || crypto.randomUUID().slice(0, 8),
+    title: String(item.title || 'New Conversation'),
+    toolId: String(item.toolId || 'codex'),
+    createdAt,
+    updatedAt: item.updatedAt || lastMessage?.createdAt || createdAt,
+    pinned: Boolean(item.pinned),
+    summary: String(item.summary || lastMessage?.content || '').slice(0, 240),
+    messages,
+  }
+}
+
+function normalizeTask(item = {}) {
+  return {
+    id: item.id || crypto.randomUUID().slice(0, 8),
+    title: String(item.title || 'Untitled Task'),
+    prompt: String(item.prompt || ''),
+    schedule: String(item.schedule || '1h'),
+    active: item.active !== false,
+    createdAt: item.createdAt || now(),
+    updatedAt: item.updatedAt || now(),
+    lastRunAt: item.lastRunAt || null,
+    lastStatus: item.lastStatus || 'idle',
+    lastResult: String(item.lastResult || ''),
+    conversationId: item.conversationId || null,
+    modelOverride: item.modelOverride ? String(item.modelOverride) : '',
+  }
+}
+
+function normalizeState(raw = {}) {
+  const state = createDefaultState()
+  state.holySheepApi = {
+    ...state.holySheepApi,
+    ...(typeof raw.holySheepApi === 'object' && raw.holySheepApi ? raw.holySheepApi : {}),
+  }
+  state.conversations = Array.isArray(raw.conversations) ? raw.conversations.map(normalizeConversation) : []
+  state.scheduledTasks = Array.isArray(raw.scheduledTasks) ? raw.scheduledTasks.map(normalizeTask) : []
+  state.updatedAt = raw.updatedAt || now()
+  return state
+}
+
+function loadState() {
+  ensureDir()
+  try {
+    if (!fs.existsSync(STATE_FILE)) {
+      return createDefaultState()
+    }
+    return normalizeState(JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')))
+  } catch {
+    return createDefaultState()
+  }
+}
+
+function saveState(next) {
+  ensureDir()
+  const normalized = normalizeState(next)
+  normalized.updatedAt = now()
+  fs.writeFileSync(STATE_FILE, JSON.stringify(normalized, null, 2), 'utf8')
+  return normalized
+}
+
+function updateState(mutator) {
+  const current = loadState()
+  const draft = clone(current)
+  const result = mutator(draft) || draft
+  return saveState(result)
+}
+
+function sortConversations(items) {
+  return [...items].sort((a, b) => {
+    if (a.pinned !== b.pinned) return a.pinned ? -1 : 1
+    return Date.parse(b.updatedAt) - Date.parse(a.updatedAt)
+  })
+}
+
+function listConversations() {
+  return sortConversations(loadState().conversations).map((item) => ({
+    id: item.id,
+    title: item.title,
+    toolId: item.toolId,
+    pinned: item.pinned,
+    summary: item.summary,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt,
+    messageCount: item.messages.length,
+  }))
+}
+
+function getConversation(id) {
+  return loadState().conversations.find((item) => item.id === id) || null
+}
+
+function ensureConversation(id) {
+  const conversation = getConversation(id)
+  if (!conversation) throw new Error('Conversation not found')
+  return conversation
+}
+
+function createConversation(payload = {}) {
+  const conversation = normalizeConversation({
+    title: payload.title || 'New Conversation',
+    toolId: payload.toolId || 'codex',
+    pinned: Boolean(payload.pinned),
+  })
+  updateState((state) => {
+    state.conversations.unshift(conversation)
+  })
+  return conversation
+}
+
+function updateConversation(id, patch = {}) {
+  let updated = null
+  updateState((state) => {
+    const index = state.conversations.findIndex((item) => item.id === id)
+    if (index === -1) throw new Error('Conversation not found')
+    const current = state.conversations[index]
+    updated = normalizeConversation({
+      ...current,
+      ...patch,
+      messages: patch.messages || current.messages,
+      updatedAt: now(),
+    })
+    state.conversations[index] = updated
+  })
+  return updated
+}
+
+function addMessage(conversationId, payload = {}) {
+  let updated = null
+  updateState((state) => {
+    const conversation = state.conversations.find((item) => item.id === conversationId)
+    if (!conversation) throw new Error('Conversation not found')
+    const message = {
+      id: payload.id || crypto.randomUUID(),
+      role: payload.role === 'assistant' ? 'assistant' : 'user',
+      content: String(payload.content || ''),
+      status: payload.status || 'done',
+      createdAt: payload.createdAt || now(),
+      meta: typeof payload.meta === 'object' && payload.meta ? payload.meta : {},
+    }
+    conversation.messages.push(message)
+    conversation.updatedAt = message.createdAt
+    if (!conversation.summary || message.role === 'assistant') {
+      conversation.summary = message.content.slice(0, 240)
+    }
+    updated = clone(message)
+  })
+  return updated
+}
+
+function searchWorkspace(query) {
+  const needle = String(query || '').trim().toLowerCase()
+  if (!needle) return { conversations: [], tasks: [] }
+
+  const state = loadState()
+  const conversations = state.conversations
+    .filter((item) => {
+      if (item.title.toLowerCase().includes(needle)) return true
+      if (String(item.summary || '').toLowerCase().includes(needle)) return true
+      return item.messages.some((message) => String(message.content || '').toLowerCase().includes(needle))
+    })
+    .map((item) => ({
+      id: item.id,
+      title: item.title,
+      summary: item.summary,
+      updatedAt: item.updatedAt,
+      toolId: item.toolId,
+    }))
+
+  const tasks = state.scheduledTasks
+    .filter((item) => {
+      return item.title.toLowerCase().includes(needle) || item.prompt.toLowerCase().includes(needle)
+    })
+    .map((item) => ({
+      id: item.id,
+      title: item.title,
+      prompt: item.prompt.slice(0, 180),
+      schedule: item.schedule,
+      active: item.active,
+      updatedAt: item.updatedAt,
+    }))
+
+  return { conversations, tasks }
+}
+
+function listTasks() {
+  return [...loadState().scheduledTasks].sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
+}
+
+function getTask(id) {
+  return loadState().scheduledTasks.find((item) => item.id === id) || null
+}
+
+function saveTask(payload = {}) {
+  let result = null
+  updateState((state) => {
+    if (payload.id) {
+      const index = state.scheduledTasks.findIndex((item) => item.id === payload.id)
+      if (index === -1) throw new Error('Task not found')
+      result = normalizeTask({
+        ...state.scheduledTasks[index],
+        ...payload,
+        updatedAt: now(),
+      })
+      state.scheduledTasks[index] = result
+      return
+    }
+    result = normalizeTask({
+      ...payload,
+      createdAt: now(),
+      updatedAt: now(),
+    })
+    state.scheduledTasks.unshift(result)
+  })
+  return result
+}
+
+function deleteTask(id) {
+  updateState((state) => {
+    state.scheduledTasks = state.scheduledTasks.filter((item) => item.id !== id)
+  })
+}
+
+function updateTaskRun(id, patch = {}) {
+  let result = null
+  updateState((state) => {
+    const index = state.scheduledTasks.findIndex((item) => item.id === id)
+    if (index === -1) throw new Error('Task not found')
+    result = normalizeTask({
+      ...state.scheduledTasks[index],
+      ...patch,
+      updatedAt: now(),
+    })
+    state.scheduledTasks[index] = result
+  })
+  return result
+}
+
+function getHolySheepApiConfig() {
+  return loadState().holySheepApi
+}
+
+function saveHolySheepApiConfig(config = {}) {
+  let result = null
+  updateState((state) => {
+    state.holySheepApi = {
+      apiKey: String(config.apiKey || state.holySheepApi.apiKey || ''),
+      baseUrl: String(config.baseUrl || state.holySheepApi.baseUrl || ''),
+      model: String(config.model || state.holySheepApi.model || ''),
+    }
+    result = clone(state.holySheepApi)
+  })
+  return result
+}
+
+module.exports = {
+  STATE_FILE,
+  loadState,
+  saveState,
+  listConversations,
+  getConversation,
+  createConversation,
+  updateConversation,
+  addMessage,
+  searchWorkspace,
+  listTasks,
+  getTask,
+  saveTask,
+  deleteTask,
+  updateTaskRun,
+  getHolySheepApiConfig,
+  saveHolySheepApiConfig,
+  ensureConversation,
+}

package/tests/workspace-store.test.js

@@ -0,0 +1,57 @@
+const assert = require('assert')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+
+const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'hs-workspace-test-'))
+process.env.HOME = tempHome
+
+const store = require('../src/webui/workspace-store')
+
+store.saveHolySheepApiConfig({
+  apiKey: 'cr_test_runtime',
+  baseUrl: 'https://api.holysheep.ai/v1',
+  model: 'gpt-5.4',
+})
+
+const conversation = store.createConversation({
+  title: 'Build workspace shell',
+  toolId: 'codex',
+})
+
+store.addMessage(conversation.id, {
+  role: 'user',
+  content: 'Need AionUi-style sidebar and search box',
+})
+
+store.addMessage(conversation.id, {
+  role: 'assistant',
+  content: 'Implement the shell and keep the HolySheep tool APIs intact.',
+})
+
+const task = store.saveTask({
+  title: 'Nightly summary',
+  prompt: 'Summarize the latest workspace changes',
+  schedule: '1h',
+  active: true,
+})
+
+const stateFile = store.STATE_FILE
+assert.ok(fs.existsSync(stateFile), 'workspace state file should be created')
+
+const loadedConversation = store.getConversation(conversation.id)
+assert.ok(loadedConversation, 'conversation should be persisted')
+assert.strictEqual(loadedConversation.messages.length, 2, 'conversation messages should be stored')
+
+const search = store.searchWorkspace('sidebar')
+assert.strictEqual(search.conversations.length, 1, 'conversation search should match message content')
+
+const tasks = store.listTasks()
+assert.strictEqual(tasks.length, 1, 'scheduled task should be persisted')
+assert.strictEqual(tasks[0].id, task.id, 'task id should remain stable')
+
+const runtime = store.getHolySheepApiConfig()
+assert.strictEqual(runtime.apiKey, 'cr_test_runtime', 'runtime api key should be stored')
+assert.strictEqual(runtime.model, 'gpt-5.4', 'runtime model should be stored')
+
+console.log('workspace store test passed')