@brimveyn/aimux 1.21.0 → 1.22.2

package/src/daemon/catalog-writer.ts

@@ -1,123 +1,123 @@
-import type { SessionRecord, WorktreeRecord } from '../state/types'
+import type { ProjectRecord, WorkspaceRecord } from '../state/types'
 
 import { logDebug } from '../debug/input-log'
 import { createPrefixedId } from '../platform/id'
-import { loadSessionCatalog, saveSessionCatalog } from '../state/session-catalog'
-import { createEmptyWorkspaceSnapshot } from '../state/session-persistence'
-import { createPrimaryWorktree, ensureSessionWorktrees } from '../state/session-worktrees'
+import { loadProjectCatalog, saveProjectCatalog } from '../state/project-catalog'
+import { createEmptyProjectSnapshot } from '../state/project-persistence'
+import { createPrimaryWorkspace, ensureProjectWorkspaces } from '../state/project-workspaces'
 
 /**
  * Catalog mutations invoked by the daemon when NO UI is attached. When a UI
  * is attached the daemon relays the request as an event and the UI's reducer
- * owns the write (so the live workspace snapshot is preserved).
+ * owns the write (so the live project snapshot is preserved).
  *
  * Each helper is a pure read-modify-write against `aimux-sessions.json` —
  * safe to call from the daemon process, no React / dispatcher involved.
  */
 
-export function createWorkspaceInCatalog(name: string, projectPath?: string): SessionRecord {
-  const sessions = loadSessionCatalog()
+export function createProjectInCatalog(name: string, projectPath?: string): ProjectRecord {
+  const projects = loadProjectCatalog()
   const now = new Date().toISOString()
-  const session: SessionRecord = {
-    activeWorktreeId: undefined,
+  const project: ProjectRecord = {
+    activeWorkspaceId: undefined,
     createdAt: now,
-    id: createPrefixedId('session'),
+    id: createPrefixedId('project'),
     lastOpenedAt: now,
     name,
     projectPath,
+    projectSnapshot: createEmptyProjectSnapshot(),
     updatedAt: now,
-    workspaceSnapshot: createEmptyWorkspaceSnapshot(),
-    worktrees: undefined,
+    workspaces: undefined,
   }
   if (projectPath != null && projectPath !== '') {
-    const worktree = createPrimaryWorktree(projectPath, now)
-    session.activeWorktreeId = worktree.id
-    session.worktrees = [worktree]
+    const workspace = createPrimaryWorkspace(projectPath, now)
+    project.activeWorkspaceId = workspace.id
+    project.workspaces = [workspace]
   }
-  saveSessionCatalog([...sessions, ensureSessionWorktrees(session)])
-  logDebug('daemon.catalog.createWorkspace', { name, projectPath, sessionId: session.id })
-  return session
+  saveProjectCatalog([...projects, ensureProjectWorkspaces(project)])
+  logDebug('daemon.catalog.createProject', { name, projectId: project.id, projectPath })
+  return project
 }
 
 /**
- * Throws when the target session isn't in the catalog. Used by the daemon
- * before broadcasting a workspace-lifecycle request so the CLI's `expectOk`
+ * Throws when the target project isn't in the catalog. Used by the daemon
+ * before broadcasting a project-lifecycle request so the CLI's `expectOk`
  * fails fast (with a meaningful message) instead of the `--wait` path
  * hanging out for its timeout while the UI silently ignores an unknown id.
  */
-export function assertSessionInCatalog(sessionId: string): void {
-  const sessions = loadSessionCatalog()
-  if (!sessions.some((s) => s.id === sessionId)) {
-    throw new Error(`workspace not found: ${sessionId}`)
+export function assertProjectInCatalog(projectId: string): void {
+  const projects = loadProjectCatalog()
+  if (!projects.some((s) => s.id === projectId)) {
+    throw new Error(`project not found: ${projectId}`)
   }
 }
 
-export function bumpLastOpenedInCatalog(sessionId: string): void {
-  const sessions = loadSessionCatalog()
+export function bumpLastOpenedInCatalog(projectId: string): void {
+  const projects = loadProjectCatalog()
   const now = new Date().toISOString()
-  const target = sessions.find((s) => s.id === sessionId)
+  const target = projects.find((s) => s.id === projectId)
   if (!target) {
-    throw new Error(`workspace not found: ${sessionId}`)
+    throw new Error(`project not found: ${projectId}`)
   }
-  const updated = sessions.map((s) => (s.id === sessionId ? { ...s, lastOpenedAt: now } : s))
-  saveSessionCatalog(updated)
-  logDebug('daemon.catalog.switchWorkspace', { sessionId })
+  const updated = projects.map((s) => (s.id === projectId ? { ...s, lastOpenedAt: now } : s))
+  saveProjectCatalog(updated)
+  logDebug('daemon.catalog.switchProject', { projectId })
 }
 
-export function deleteFromCatalog(sessionId: string): void {
-  const sessions = loadSessionCatalog()
-  const remaining = sessions.filter((s) => s.id !== sessionId)
-  if (remaining.length === sessions.length) {
-    throw new Error(`workspace not found: ${sessionId}`)
+export function deleteFromCatalog(projectId: string): void {
+  const projects = loadProjectCatalog()
+  const remaining = projects.filter((s) => s.id !== projectId)
+  if (remaining.length === projects.length) {
+    throw new Error(`project not found: ${projectId}`)
   }
-  saveSessionCatalog(remaining)
-  logDebug('daemon.catalog.closeWorkspace', { sessionId })
+  saveProjectCatalog(remaining)
+  logDebug('daemon.catalog.closeProject', { projectId })
 }
 
-export function addWorktreeToCatalog(sessionId: string, worktree: WorktreeRecord): void {
-  const sessions = loadSessionCatalog()
-  const target = sessions.find((s) => s.id === sessionId)
+export function addWorkspaceToCatalog(projectId: string, workspace: WorkspaceRecord): void {
+  const projects = loadProjectCatalog()
+  const target = projects.find((s) => s.id === projectId)
   if (!target) {
-    throw new Error(`workspace not found: ${sessionId}`)
+    throw new Error(`project not found: ${projectId}`)
   }
-  const existing = target.worktrees ?? []
-  if (existing.some((w) => w.id === worktree.id)) {
-    throw new Error(`worktree already exists: ${worktree.id}`)
+  const existing = target.workspaces ?? []
+  if (existing.some((w) => w.id === workspace.id)) {
+    throw new Error(`workspace already exists: ${workspace.id}`)
   }
-  const updated = sessions.map((s) =>
-    s.id === sessionId
-      ? { ...s, updatedAt: new Date().toISOString(), worktrees: [...existing, worktree] }
+  const updated = projects.map((s) =>
+    s.id === projectId
+      ? { ...s, updatedAt: new Date().toISOString(), workspaces: [...existing, workspace] }
       : s
   )
-  saveSessionCatalog(updated)
-  logDebug('daemon.catalog.addWorktree', {
-    sessionId,
-    worktreeId: worktree.id,
-    worktreeName: worktree.name,
+  saveProjectCatalog(updated)
+  logDebug('daemon.catalog.addWorkspace', {
+    projectId,
+    workspaceId: workspace.id,
+    workspaceName: workspace.name,
   })
 }
 
-export function removeWorktreeFromCatalog(sessionId: string, worktreeId: string): void {
-  const sessions = loadSessionCatalog()
-  const target = sessions.find((s) => s.id === sessionId)
+export function removeWorkspaceFromCatalog(projectId: string, workspaceId: string): void {
+  const projects = loadProjectCatalog()
+  const target = projects.find((s) => s.id === projectId)
   if (!target) {
-    throw new Error(`workspace not found: ${sessionId}`)
+    throw new Error(`project not found: ${projectId}`)
   }
-  const existing = target.worktrees ?? []
-  const nextWorktrees = existing.filter((w) => w.id !== worktreeId)
-  if (nextWorktrees.length === existing.length) {
-    throw new Error(`worktree not found: ${worktreeId}`)
+  const existing = target.workspaces ?? []
+  const nextWorkspaces = existing.filter((w) => w.id !== workspaceId)
+  if (nextWorkspaces.length === existing.length) {
+    throw new Error(`workspace not found: ${workspaceId}`)
   }
-  const updated = sessions.map((s) =>
-    s.id === sessionId
+  const updated = projects.map((s) =>
+    s.id === projectId
       ? {
           ...s,
-          activeWorktreeId: s.activeWorktreeId === worktreeId ? undefined : s.activeWorktreeId,
+          activeWorkspaceId: s.activeWorkspaceId === workspaceId ? undefined : s.activeWorkspaceId,
           updatedAt: new Date().toISOString(),
-          worktrees: nextWorktrees,
+          workspaces: nextWorkspaces,
         }
       : s
   )
-  saveSessionCatalog(updated)
-  logDebug('daemon.catalog.removeWorktree', { sessionId, worktreeId })
+  saveProjectCatalog(updated)
+  logDebug('daemon.catalog.removeWorkspace', { projectId, workspaceId })
 }