@phenx-inc/ctlsurf 0.3.13 → 0.3.14

package/src/main/index.ts

@@ -366,6 +366,26 @@ ipcMain.handle('tracking:set', async (_event, enabled: boolean) => {
   return { active: orchestrator.isActiveTabTracking() }
 })
 
+// ─── Tickets IPC ──────────────────────────────────
+
+ipcMain.handle('tickets:project', () => {
+  const cwd = orchestrator.getActiveTabCwd()
+  return { cwd, name: cwd ? cwd.split('/').filter(Boolean).pop() || cwd : null }
+})
+ipcMain.handle('tickets:add', async (_event, input: {
+  title: string; description?: string; status?: string; priority?: string
+}) => {
+  return orchestrator.addTicketForActiveTab(input)
+})
+ipcMain.handle('tickets:update', async (_event, rowId: string, input: {
+  title: string; description?: string; status?: string; priority?: string
+}) => {
+  return orchestrator.updateTicketForActiveTab(rowId, input)
+})
+ipcMain.handle('tickets:list', async () => {
+  return orchestrator.listTicketsForActiveTab()
+})
+
 // ─── Legacy Settings IPC ──────────────────────────
 
 ipcMain.handle('settings:get', (_event, key: string) => {

package/src/main/orchestrator.ts

@@ -8,6 +8,7 @@ import { CtlsurfApi } from './ctlsurfApi'
 import { ConversationBridge } from './bridge'
 import { WorkerWsClient, type WorkerWsStatus, type IncomingMessage } from './workerWs'
 import { TimeTracker } from './timeTracker'
+import { TicketStore, type TicketInput } from './ticketStore'
 import { log } from './logger'
 
 // ─── Types ────────────────────────────────────────
@@ -74,6 +75,7 @@ export class Orchestrator {
   readonly bridge = new ConversationBridge()
   readonly workerWs: WorkerWsClient
   readonly timeTracker = new TimeTracker(this.ctlsurfApi)
+  readonly ticketStore = new TicketStore(this.ctlsurfApi)
 
   // State
   private tabs = new Map<string, TabState>()
@@ -480,6 +482,41 @@ export class Orchestrator {
     }
   }
 
+  // ─── Tickets (active tab) ───────────────────────
+
+  /** cwd of the focused terminal tab, or null if no tab is active. */
+  getActiveTabCwd(): string | null {
+    if (!this.activeTabId) return null
+    return this.tabs.get(this.activeTabId)?.cwd ?? null
+  }
+
+  async addTicketForActiveTab(input: TicketInput): Promise<{ ok: boolean; error?: string }> {
+    const cwd = this.getActiveTabCwd()
+    if (!cwd) return { ok: false, error: 'No active terminal tab' }
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, error: 'ctlsurf API key not configured' }
+    }
+    return this.ticketStore.addTicket(cwd, input)
+  }
+
+  async updateTicketForActiveTab(rowId: string, input: TicketInput): Promise<{ ok: boolean; error?: string }> {
+    const cwd = this.getActiveTabCwd()
+    if (!cwd) return { ok: false, error: 'No active terminal tab' }
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, error: 'ctlsurf API key not configured' }
+    }
+    return this.ticketStore.updateTicket(cwd, rowId, input)
+  }
+
+  async listTicketsForActiveTab(): Promise<{ ok: boolean; tickets: import('./ticketStore').Ticket[]; error?: string }> {
+    const cwd = this.getActiveTabCwd()
+    if (!cwd) return { ok: false, tickets: [], error: 'No active terminal tab' }
+    if (!this.ctlsurfApi.getApiKey()) {
+      return { ok: false, tickets: [], error: 'ctlsurf API key not configured' }
+    }
+    return this.ticketStore.listTickets(cwd)
+  }
+
   // ─── Worker WebSocket ───────────────────────────
 
   connectWorkerWs(agent: AgentConfig, cwd: string): void {

package/src/main/ticketStore.ts

@@ -0,0 +1,252 @@
+import type { CtlsurfApi } from './ctlsurfApi'
+
+const DATASTORE_TITLE = 'Tickets'
+const AGENT_DATASTORE_PAGE_TITLE = 'Agent Datastore'
+const SYSTEM_KEY = 'tickets' // stable identifier in props.system_key; lookup survives title rename
+
+const STATUS_OPTIONS = [
+  { value: 'Open', color: 'blue' },
+  { value: 'In Progress', color: 'yellow' },
+  { value: 'Blocked', color: 'red' },
+  { value: 'Done', color: 'green' },
+]
+const PRIORITY_OPTIONS = [
+  { value: 'Low', color: 'gray' },
+  { value: 'Med', color: 'yellow' },
+  { value: 'High', color: 'red' },
+]
+
+interface ColumnSpec {
+  name: string
+  type: string
+  options?: Array<{ value: string; color?: string }>
+}
+
+const COLUMNS: ColumnSpec[] = [
+  { name: 'Title', type: 'text' },
+  { name: 'Description', type: 'text' },
+  { name: 'Status', type: 'select', options: STATUS_OPTIONS },
+  { name: 'Priority', type: 'select', options: PRIORITY_OPTIONS },
+  { name: 'Created', type: 'date' },
+]
+
+export interface TicketInput {
+  title: string
+  description?: string
+  status?: string
+  priority?: string
+}
+
+export interface Ticket {
+  id: string
+  title: string
+  description: string
+  status: string
+  priority: string
+  created: string | null
+}
+
+function log(...args: unknown[]): void {
+  try { console.log('[ticket-store]', ...args) } catch { /* EPIPE safe */ }
+}
+
+function findPageByTitle(pages: any[], title: string): any | null {
+  for (const p of pages) {
+    if (p?.title === title) return p
+    if (p?.children?.length) {
+      const c = findPageByTitle(p.children, title)
+      if (c) return c
+    }
+  }
+  return null
+}
+
+/**
+ * Per-project `Tickets` datastore manager. Mirrors TimeTracker's datastore
+ * resolution (find folder → Agent Datastore page → find/create block by
+ * system_key), minus all the session/checkpoint machinery — a ticket is a
+ * single manual capture, not a tracked session.
+ */
+export class TicketStore {
+  private api: CtlsurfApi
+  private blockCache = new Map<string, string>()
+
+  constructor(api: CtlsurfApi) {
+    this.api = api
+  }
+
+  /** Resolves (or creates) the project's Tickets datastore and appends a row. */
+  async addTicket(cwd: string, input: TicketInput): Promise<{ ok: boolean; error?: string }> {
+    const title = input.title?.trim()
+    if (!title) return { ok: false, error: 'Title is required' }
+    try {
+      const blockId = await this.ensureDatastore(cwd, true)
+      if (!blockId) {
+        return { ok: false, error: 'No ctlsurf project found for this folder' }
+      }
+      await this.api.addRow(blockId, {
+        Title: title,
+        Description: input.description?.trim() || '',
+        Status: input.status || 'Open',
+        Priority: input.priority || 'Med',
+        Created: new Date().toISOString(),
+      })
+      log(`Added ticket "${title}" for ${cwd}`)
+      return { ok: true }
+    } catch (err: any) {
+      log(`addTicket failed for ${cwd}: ${err?.message || err}`)
+      return { ok: false, error: err?.message || String(err) }
+    }
+  }
+
+  /** Updates an existing ticket row in the project's Tickets datastore. */
+  async updateTicket(cwd: string, rowId: string, input: TicketInput): Promise<{ ok: boolean; error?: string }> {
+    const title = input.title?.trim()
+    if (!title) return { ok: false, error: 'Title is required' }
+    try {
+      const blockId = await this.ensureDatastore(cwd, false)
+      if (!blockId) return { ok: false, error: 'No Tickets datastore for this project' }
+      await this.api.updateRow(blockId, rowId, {
+        Title: title,
+        Description: input.description?.trim() || '',
+        Status: input.status || 'Open',
+        Priority: input.priority || 'Med',
+      })
+      log(`Updated ticket ${rowId} for ${cwd}`)
+      return { ok: true }
+    } catch (err: any) {
+      log(`updateTicket failed for ${cwd}: ${err?.message || err}`)
+      return { ok: false, error: err?.message || String(err) }
+    }
+  }
+
+  /** Lists existing tickets for the project, newest first. Does not create the
+   * datastore — an unconfigured project simply has no tickets yet. */
+  async listTickets(cwd: string): Promise<{ ok: boolean; tickets: Ticket[]; error?: string }> {
+    try {
+      const blockId = await this.ensureDatastore(cwd, false)
+      if (!blockId) return { ok: true, tickets: [] }
+      const res = await this.api.queryRows(blockId, { orderBy: 'Created', order: 'desc', limit: 200 })
+      const tickets: Ticket[] = (res?.rows || []).map(r => ({
+        id: r.id,
+        title: String(r.data?.Title ?? ''),
+        description: String(r.data?.Description ?? ''),
+        status: String(r.data?.Status ?? 'Open'),
+        priority: String(r.data?.Priority ?? 'Med'),
+        created: (r.data?.Created as string) ?? r.created_at ?? null,
+      }))
+      return { ok: true, tickets }
+    } catch (err: any) {
+      log(`listTickets failed for ${cwd}: ${err?.message || err}`)
+      return { ok: false, tickets: [], error: err?.message || String(err) }
+    }
+  }
+
+  private async ensureDatastore(cwd: string, create: boolean): Promise<string | null> {
+    const cached = this.blockCache.get(cwd)
+    if (cached) return cached
+
+    let folder: any = null
+    try {
+      folder = await this.api.findFolderByPath(cwd)
+    } catch {
+      return null
+    }
+    if (!folder?.id) return null
+
+    const folderDetail = await this.api.getFolder(folder.id)
+    const agentPage = findPageByTitle(folderDetail?.pages || [], AGENT_DATASTORE_PAGE_TITLE)
+    if (!agentPage?.id) return null
+
+    const blockId = await this.findOrAdoptBlock(agentPage.id)
+    if (blockId) {
+      await this.ensureColumns(blockId)
+      this.blockCache.set(cwd, blockId)
+      return blockId
+    }
+
+    if (!create) return null
+
+    const columns = COLUMNS.map((c, i) => ({
+      id: `col_${i}`,
+      name: c.name,
+      type: c.type,
+      ...(c.options ? { options: c.options } : {}),
+    }))
+    const created = await this.api.createBlock(agentPage.id, {
+      type: 'datastore',
+      title: DATASTORE_TITLE,
+      props: { columns, system_key: SYSTEM_KEY },
+    })
+    if (created?.id) {
+      log(`Created "${DATASTORE_TITLE}" datastore on Agent Datastore page for ${cwd}`)
+      this.blockCache.set(cwd, created.id)
+      return created.id
+    }
+    return null
+  }
+
+  /** Finds an existing Tickets block on the page. Prefers a system_key match
+   * (which survives title renames). Falls back to title match for legacy blocks
+   * and backfills system_key on the way out. */
+  private async findOrAdoptBlock(pageId: string): Promise<string | null> {
+    const summaries = (await this.api.getPageBlockSummaries(pageId)) || []
+    const datastoreSummaries = summaries.filter((b: any) => b?.type === 'datastore' && b?.id)
+    if (datastoreSummaries.length === 0) return null
+
+    let titleFallbackId: string | null = null
+    let titleFallbackProps: Record<string, unknown> | null = null
+    for (const s of datastoreSummaries) {
+      try {
+        const block = await this.api.getBlock(s.id)
+        const props = (block?.props || {}) as Record<string, unknown>
+        if (props.system_key === SYSTEM_KEY) {
+          return s.id
+        }
+        if (s.title === DATASTORE_TITLE && titleFallbackId === null) {
+          titleFallbackId = s.id
+          titleFallbackProps = props
+        }
+      } catch (err: any) {
+        log(`getBlock(${s.id}) failed during lookup: ${err?.message || err}`)
+      }
+    }
+
+    if (titleFallbackId) {
+      try {
+        await this.api.updateBlock(titleFallbackId, {
+          props: { ...(titleFallbackProps || {}), system_key: SYSTEM_KEY },
+        })
+        log(`Backfilled system_key on legacy Tickets block ${titleFallbackId}`)
+      } catch (err: any) {
+        log(`backfill system_key failed on ${titleFallbackId}: ${err?.message || err}`)
+      }
+      return titleFallbackId
+    }
+    return null
+  }
+
+  private async ensureColumns(blockId: string): Promise<void> {
+    try {
+      const schema = await this.api.getDatastoreSchema(blockId)
+      const existingCols = schema.columns || []
+      const existingNames = new Set(existingCols.map(c => c.name))
+      const missing = COLUMNS.filter(c => !existingNames.has(c.name))
+      if (missing.length === 0) return
+
+      const usedIds = new Set(existingCols.map(c => c.id))
+      let nextIdx = existingCols.length
+      const appended = missing.map(c => {
+        let id = `col_${nextIdx++}`
+        while (usedIds.has(id)) id = `col_${nextIdx++}`
+        usedIds.add(id)
+        return { id, name: c.name, type: c.type, ...(c.options ? { options: c.options } : {}) }
+      })
+      const merged = [...existingCols, ...appended]
+      await this.api.updateDatastoreSchema(blockId, merged)
+      log(`Added ${missing.length} missing column(s) to existing Tickets datastore: ${missing.map(c => c.name).join(', ')}`)
+    } catch (err: any) {
+      log(`ensureColumns failed: ${err?.message || err}`)
+    }
+  }
+}

package/src/preload/index.ts

@@ -82,6 +82,16 @@ const api = {
   setTracking: (enabled: boolean): Promise<{ active: boolean }> =>
     ipcRenderer.invoke('tracking:set', enabled),
 
+  // Tickets (active tab)
+  getTicketProject: (): Promise<{ cwd: string | null; name: string | null }> =>
+    ipcRenderer.invoke('tickets:project'),
+  addTicket: (input: { title: string; description?: string; status?: string; priority?: string }): Promise<{ ok: boolean; error?: string }> =>
+    ipcRenderer.invoke('tickets:add', input),
+  updateTicket: (rowId: string, input: { title: string; description?: string; status?: string; priority?: string }): Promise<{ ok: boolean; error?: string }> =>
+    ipcRenderer.invoke('tickets:update', rowId, input),
+  listTickets: (): Promise<{ ok: boolean; tickets: Array<{ id: string; title: string; description: string; status: string; priority: string; created: string | null }>; error?: string }> =>
+    ipcRenderer.invoke('tickets:list'),
+
   // Chat logging (global)
   getLogChat: (): Promise<{ enabled: boolean }> =>
     ipcRenderer.invoke('logchat:get'),

package/src/renderer/App.tsx

@@ -12,6 +12,7 @@ import {
 } from './components/PaneLayout'
 import { StatusBar } from './components/StatusBar'
 import { SettingsDialog } from './components/SettingsDialog'
+import { TicketPanel } from './components/TicketPanel'
 
 interface AgentConfig {
   id: string
@@ -44,6 +45,10 @@ declare global {
       saveProfile: (profileId: string, data: { name: string; apiKey?: string; baseUrl: string; dataspacePageId: string }) => Promise<{ ok: boolean }>
       switchProfile: (profileId: string) => Promise<{ ok: boolean }>
       deleteProfile: (profileId: string) => Promise<{ ok: boolean }>
+      getTicketProject: () => Promise<{ cwd: string | null; name: string | null }>
+      addTicket: (input: { title: string; description?: string; status?: string; priority?: string }) => Promise<{ ok: boolean; error?: string }>
+      updateTicket: (rowId: string, input: { title: string; description?: string; status?: string; priority?: string }) => Promise<{ ok: boolean; error?: string }>
+      listTickets: () => Promise<{ ok: boolean; tickets: Array<{ id: string; title: string; description: string; status: string; priority: string; created: string | null }>; error?: string }>
       getTracking: () => Promise<{ active: boolean }>
       setTracking: (enabled: boolean) => Promise<{ active: boolean }>
       getLogChat: () => Promise<{ enabled: boolean }>
@@ -116,6 +121,7 @@ export default function App() {
   })
   const [activeTabId, setActiveTabId] = useState<string>(tabs[0].id)
   const [trackingActive, setTrackingActive] = useState(false)
+  const [showTicketPanel, setShowTicketPanel] = useState(false)
 
   // Agent picker state: which tab is being configured (null = initial picker for first tab)
   const [pickerTargetTabId, setPickerTargetTabId] = useState<string | null>(tabs[0].id)
@@ -412,6 +418,20 @@ export default function App() {
             <span className="tracking-icon">⏱</span>
             <span className={`tracking-dot ${trackingActive ? 'on' : 'off'}`} />
           </button>
+          <button
+            className={`titlebar-btn titlebar-icon-btn ${showTicketPanel ? 'active' : ''}`}
+            onClick={() => setShowTicketPanel(v => !v)}
+            title="Tickets for the active project"
+            aria-label="Tickets"
+          >
+            <svg className="ticket-tag-icon" viewBox="0 0 24 24" width="13" height="13"
+              fill="none" stroke="currentColor" strokeWidth="2"
+              strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+              <path d="M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z" />
+              <line x1="7" y1="7" x2="7.01" y2="7" />
+            </svg>
+            <span>Tickets</span>
+          </button>
           <span className="titlebar-separator" />
           {agents.map(a => {
             const activeTab = tabs.find(t => t.id === activeTabId)
@@ -457,6 +477,7 @@ export default function App() {
 
       <StatusBar wsStatus={wsStatus} cwd={cwd} onChangeCwd={handleChangeCwd} updateInfo={updateInfo} />
       <SettingsDialog open={showSettings} onClose={() => setShowSettings(false)} />
+      <TicketPanel open={showTicketPanel} onClose={() => setShowTicketPanel(false)} />
 
       {showAgentPicker && agents.length > 0 && (
         <AgentPicker