@swarmclawai/swarmclaw 0.7.7 → 0.7.8

package/src/lib/server/project-context.ts

@@ -0,0 +1,162 @@
+import path from 'path'
+import type { Project } from '@/types'
+import { WORKSPACE_DIR } from './data-dir'
+import { loadAgents, loadProjects } from './storage'
+import { buildProjectSnapshot, type ProjectResourceSummary } from './project-utils'
+
+export interface ActiveProjectContext {
+  projectId: string | null
+  project: (Project & { workspaceRoot: string; resourceSummary: ProjectResourceSummary }) | null
+  projectRoot: string | null
+  objective: string | null
+  audience: string | null
+  priorities: string[]
+  openObjectives: string[]
+  capabilityHints: string[]
+  credentialRequirements: string[]
+  successMetrics: string[]
+  heartbeatPrompt: string | null
+  heartbeatIntervalSec: number | null
+  resourceSummary: ProjectResourceSummary | null
+}
+
+function normalizeProjectId(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null
+}
+
+function inferProjectIdFromCwd(cwd: unknown): string | null {
+  if (typeof cwd !== 'string' || !cwd.trim()) return null
+  const projectsRoot = path.resolve(path.join(WORKSPACE_DIR, 'projects'))
+  const resolvedCwd = path.resolve(cwd)
+  const relative = path.relative(projectsRoot, resolvedCwd)
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return null
+  const [projectId] = relative.split(path.sep).filter(Boolean)
+  return normalizeProjectId(projectId)
+}
+
+function extractProjectHints(project: Project | null): {
+  objective: string | null
+  audience: string | null
+  priorities: string[]
+  openObjectives: string[]
+  capabilityHints: string[]
+  credentialRequirements: string[]
+  successMetrics: string[]
+  heartbeatPrompt: string | null
+  heartbeatIntervalSec: number | null
+} {
+  if (!project) {
+    return {
+      objective: null,
+      audience: null,
+      priorities: [],
+      openObjectives: [],
+      capabilityHints: [],
+      credentialRequirements: [],
+      successMetrics: [],
+      heartbeatPrompt: null,
+      heartbeatIntervalSec: null,
+    }
+  }
+  if (
+    project.objective
+    || project.audience
+    || project.priorities?.length
+    || project.openObjectives?.length
+    || project.capabilityHints?.length
+    || project.credentialRequirements?.length
+    || project.successMetrics?.length
+    || project.heartbeatPrompt
+    || typeof project.heartbeatIntervalSec === 'number'
+  ) {
+    return {
+      objective: project.objective || null,
+      audience: project.audience || null,
+      priorities: Array.isArray(project.priorities) ? project.priorities : [],
+      openObjectives: Array.isArray(project.openObjectives) ? project.openObjectives : [],
+      capabilityHints: Array.isArray(project.capabilityHints) ? project.capabilityHints : [],
+      credentialRequirements: Array.isArray(project.credentialRequirements) ? project.credentialRequirements : [],
+      successMetrics: Array.isArray(project.successMetrics) ? project.successMetrics : [],
+      heartbeatPrompt: project.heartbeatPrompt || null,
+      heartbeatIntervalSec: typeof project.heartbeatIntervalSec === 'number' ? project.heartbeatIntervalSec : null,
+    }
+  }
+
+  const description = project.description || ''
+  if (!description) {
+    return {
+      objective: null,
+      audience: null,
+      priorities: [],
+      openObjectives: [],
+      capabilityHints: [],
+      credentialRequirements: [],
+      successMetrics: [],
+      heartbeatPrompt: null,
+      heartbeatIntervalSec: null,
+    }
+  }
+  const audienceMatch = description.match(/\bfor\s+([^.!?]+?)(?:\.|,|;|$)/i)
+  const objectiveMatch = description.match(/^([^.!?]+?)(?:\.|!|\?)/)
+  const focusMatch = description.match(/\b(?:focused on|focuses on|pilot priorities(?: are| include)?|priority is)\s+([^.!?]+)/i)
+  const audience = normalizeProjectId(audienceMatch?.[1]?.replace(/^the\s+/i, '').trim()) || null
+  const priorities = (focusMatch?.[1] || '')
+    .split(/\s+(?:and|&)\s+|,\s+/)
+    .map((value) => value.trim())
+    .filter((value) => value.length > 0)
+    .slice(0, 4)
+  return {
+    objective: normalizeProjectId(objectiveMatch?.[1]?.trim()) || null,
+    audience,
+    priorities,
+    openObjectives: [],
+    capabilityHints: [],
+    credentialRequirements: [],
+    successMetrics: [],
+    heartbeatPrompt: null,
+    heartbeatIntervalSec: null,
+  }
+}
+
+export function resolveActiveProjectContext(sessionLike: { agentId?: string | null; cwd?: string | null; projectId?: string | null }): ActiveProjectContext {
+  const agents = loadAgents()
+  const projects = loadProjects() as Record<string, Project>
+  const explicitProjectId = normalizeProjectId(sessionLike.projectId)
+  const agentProjectId = normalizeProjectId(sessionLike.agentId ? agents[sessionLike.agentId]?.projectId : null)
+  const cwdProjectId = inferProjectIdFromCwd(sessionLike.cwd)
+  const projectId = explicitProjectId || agentProjectId || cwdProjectId
+  if (!projectId) {
+    return {
+      projectId: null,
+      project: null,
+      projectRoot: null,
+      objective: null,
+      audience: null,
+      priorities: [],
+      openObjectives: [],
+      capabilityHints: [],
+      credentialRequirements: [],
+      successMetrics: [],
+      heartbeatPrompt: null,
+      heartbeatIntervalSec: null,
+      resourceSummary: null,
+    }
+  }
+  const project = projects[projectId] ? buildProjectSnapshot(projects[projectId]) : null
+  const hints = extractProjectHints(project)
+  return {
+    projectId,
+    project,
+    projectRoot: project?.workspaceRoot || path.join(WORKSPACE_DIR, 'projects', projectId),
+    objective: hints.objective,
+    audience: hints.audience,
+    priorities: hints.priorities,
+    openObjectives: hints.openObjectives,
+    capabilityHints: hints.capabilityHints,
+    credentialRequirements: hints.credentialRequirements,
+    successMetrics: hints.successMetrics,
+    heartbeatPrompt: hints.heartbeatPrompt,
+    heartbeatIntervalSec: hints.heartbeatIntervalSec,
+    resourceSummary: project?.resourceSummary || null,
+  }
+}

package/src/lib/server/project-utils.ts

@@ -0,0 +1,150 @@
+import fs from 'fs'
+import path from 'path'
+import type { OrchestratorSecret, Project, Schedule, Skill, BoardTask } from '@/types'
+import { WORKSPACE_DIR } from './data-dir'
+import { loadSchedules, loadSecrets, loadSkills, loadTasks } from './storage'
+
+function normalizeText(value: unknown, maxLen = 400): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.replace(/\s+/g, ' ').trim()
+  if (!trimmed) return undefined
+  return trimmed.slice(0, maxLen)
+}
+
+function normalizeColor(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim()
+  if (!trimmed) return undefined
+  return trimmed.slice(0, 32)
+}
+
+function normalizeStringArray(value: unknown, maxItems = 8, maxLen = 160): string[] | undefined {
+  const rawItems = Array.isArray(value)
+    ? value
+    : typeof value === 'string'
+      ? value.split(/\r?\n|[,;]+/)
+      : []
+  const items = rawItems
+    .map((entry) => typeof entry === 'string' ? entry.replace(/\s+/g, ' ').trim() : '')
+    .filter(Boolean)
+    .slice(0, maxItems)
+    .map((entry) => entry.slice(0, maxLen))
+  return items.length > 0 ? items : undefined
+}
+
+function normalizeInteger(value: unknown, min: number, max: number): number | undefined {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return undefined
+  return Math.max(min, Math.min(max, Math.trunc(parsed)))
+}
+
+export function normalizeProjectCreateInput(input: Record<string, unknown>): Omit<Project, 'id' | 'createdAt' | 'updatedAt'> {
+  return {
+    name: normalizeText(input.name, 140) || 'Unnamed Project',
+    description: normalizeText(input.description, 4000) || '',
+    color: normalizeColor(input.color),
+    objective: normalizeText(input.objective, 240),
+    audience: normalizeText(input.audience, 240),
+    priorities: normalizeStringArray(input.priorities, 10),
+    openObjectives: normalizeStringArray(input.openObjectives, 12),
+    capabilityHints: normalizeStringArray(input.capabilityHints, 12),
+    credentialRequirements: normalizeStringArray(input.credentialRequirements, 12),
+    successMetrics: normalizeStringArray(input.successMetrics, 10),
+    heartbeatPrompt: normalizeText(input.heartbeatPrompt, 300),
+    heartbeatIntervalSec: normalizeInteger(input.heartbeatIntervalSec, 0, 86_400),
+  }
+}
+
+export function normalizeProjectPatchInput(input: Record<string, unknown>): Partial<Project> {
+  const patch: Partial<Project> = {}
+
+  if ('name' in input) patch.name = normalizeText(input.name, 140) || 'Unnamed Project'
+  if ('description' in input) patch.description = normalizeText(input.description, 4000) || ''
+  if ('color' in input) patch.color = normalizeColor(input.color)
+  if ('objective' in input) patch.objective = normalizeText(input.objective, 240)
+  if ('audience' in input) patch.audience = normalizeText(input.audience, 240)
+  if ('priorities' in input) patch.priorities = normalizeStringArray(input.priorities, 10) || []
+  if ('openObjectives' in input) patch.openObjectives = normalizeStringArray(input.openObjectives, 12) || []
+  if ('capabilityHints' in input) patch.capabilityHints = normalizeStringArray(input.capabilityHints, 12) || []
+  if ('credentialRequirements' in input) patch.credentialRequirements = normalizeStringArray(input.credentialRequirements, 12) || []
+  if ('successMetrics' in input) patch.successMetrics = normalizeStringArray(input.successMetrics, 10) || []
+  if ('heartbeatPrompt' in input) patch.heartbeatPrompt = normalizeText(input.heartbeatPrompt, 300)
+  if ('heartbeatIntervalSec' in input) patch.heartbeatIntervalSec = normalizeInteger(input.heartbeatIntervalSec, 0, 86_400)
+
+  return patch
+}
+
+export function projectWorkspaceRoot(projectId: string): string {
+  return path.join(WORKSPACE_DIR, 'projects', projectId)
+}
+
+export function ensureProjectWorkspace(projectId: string, projectName?: string): string {
+  const root = projectWorkspaceRoot(projectId)
+  fs.mkdirSync(root, { recursive: true })
+  const readmePath = path.join(root, 'README.md')
+  if (!fs.existsSync(readmePath)) {
+    const title = (projectName || 'Project Workspace').trim() || 'Project Workspace'
+    fs.writeFileSync(readmePath, `# ${title}\n\nThis workspace belongs to project ${projectId}.\n`, 'utf8')
+  }
+  return root
+}
+
+export interface ProjectResourceSummary {
+  openTaskCount: number
+  queuedTaskCount: number
+  runningTaskCount: number
+  activeScheduleCount: number
+  secretCount: number
+  skillCount: number
+  topTaskTitles: string[]
+  scheduleNames: string[]
+  secretNames: string[]
+}
+
+function byUpdatedDesc<T extends { updatedAt?: number; createdAt?: number }>(a: T, b: T): number {
+  return (Number(b.updatedAt || b.createdAt || 0) - Number(a.updatedAt || a.createdAt || 0))
+}
+
+export function summarizeProjectResources(projectId: string): ProjectResourceSummary {
+  const tasks = Object.values(loadTasks() as Record<string, BoardTask>)
+    .filter((task) => task?.projectId === projectId)
+  const schedules = Object.values(loadSchedules() as Record<string, Schedule>)
+    .filter((schedule) => schedule?.projectId === projectId)
+  const secrets = Object.values(loadSecrets() as Record<string, OrchestratorSecret & { projectId?: string }>)
+    .filter((secret) => secret?.projectId === projectId)
+  const skills = Object.values(loadSkills() as Record<string, Skill>)
+    .filter((skill) => skill?.projectId === projectId)
+
+  const openTasks = tasks
+    .filter((task) => ['backlog', 'queued', 'running'].includes(String(task.status || '').toLowerCase()))
+    .sort(byUpdatedDesc)
+  const activeSchedules = schedules
+    .filter((schedule) => String(schedule.status || '').toLowerCase() === 'active')
+    .sort(byUpdatedDesc)
+  const recentSecrets = secrets
+    .slice()
+    .sort(byUpdatedDesc)
+
+  return {
+    openTaskCount: openTasks.length,
+    queuedTaskCount: openTasks.filter((task) => task.status === 'queued').length,
+    runningTaskCount: openTasks.filter((task) => task.status === 'running').length,
+    activeScheduleCount: activeSchedules.length,
+    secretCount: secrets.length,
+    skillCount: skills.length,
+    topTaskTitles: openTasks.slice(0, 3).map((task) => String(task.title || '').trim()).filter(Boolean),
+    scheduleNames: activeSchedules.slice(0, 3).map((schedule) => String(schedule.name || '').trim()).filter(Boolean),
+    secretNames: recentSecrets.slice(0, 3).map((secret) => String(secret.name || '').trim()).filter(Boolean),
+  }
+}
+
+export function buildProjectSnapshot(project: Project): Project & {
+  workspaceRoot: string
+  resourceSummary: ProjectResourceSummary
+} {
+  return {
+    ...project,
+    workspaceRoot: ensureProjectWorkspace(project.id, project.name),
+    resourceSummary: summarizeProjectResources(project.id),
+  }
+}

package/src/lib/server/queue-followups.test.ts

@@ -1,7 +1,13 @@
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import type { BoardTask } from '@/types'
-import { resolveTaskOriginConnectorFollowupTarget } from './queue'
+import type { BoardTask, Session } from '@/types'
+import {
+  applyTaskResumeStateToSession,
+  dequeueNextRunnableTask,
+  resolveTaskOriginConnectorFollowupTarget,
+  resolveTaskResumeContext,
+  resolveReusableTaskSessionId,
+} from './queue'
 
 function makeTask(partial?: Partial<BoardTask> & { createdInSessionId?: string | null }): BoardTask {
   const now = Date.now()
@@ -222,3 +228,142 @@ describe('resolveTaskOriginConnectorFollowupTarget', () => {
     })
   })
 })
+
+describe('task resume context', () => {
+  it('falls back to delegated parent task resume handles for follow-up work', () => {
+    const parent = makeTask({
+      id: 'task-parent',
+      title: 'Parent task',
+      codexResumeId: 'codex-thread-123',
+      geminiResumeId: 'gemini-session-123',
+      sessionId: 'session-parent',
+    })
+    const child = makeTask({
+      id: 'task-child',
+      title: 'Child task',
+      delegatedFromTaskId: 'task-parent',
+    })
+
+    const context = resolveTaskResumeContext(child, {
+      [parent.id]: parent,
+      [child.id]: child,
+    })
+
+    assert.ok(context)
+    assert.equal(context?.source, 'delegated_from_task')
+    assert.equal(context?.sourceTaskId, 'task-parent')
+    assert.equal(context?.sourceSessionId, 'session-parent')
+    assert.equal(context?.resume.codexThreadId, 'codex-thread-123')
+    assert.equal(context?.resume.delegateResumeIds.gemini, 'gemini-session-123')
+  })
+
+  it('hydrates task execution sessions with stored resume state', () => {
+    const session = {
+      id: 'session-task',
+      name: 'Task session',
+      cwd: process.cwd(),
+      user: 'system',
+      provider: 'codex-cli',
+      model: 'gpt-5-codex',
+      claudeSessionId: null,
+      codexThreadId: null,
+      opencodeSessionId: null,
+      delegateResumeIds: { claudeCode: null, codex: null, opencode: null, gemini: null },
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      sessionType: 'human',
+      agentId: 'agent-a',
+      parentSessionId: null,
+      plugins: ['delegate'],
+    } satisfies Session
+
+    const changed = applyTaskResumeStateToSession(session, {
+      claudeSessionId: 'claude-resume-1',
+      codexThreadId: 'codex-resume-1',
+      opencodeSessionId: 'opencode-resume-1',
+      delegateResumeIds: {
+        claudeCode: 'claude-resume-1',
+        codex: 'codex-resume-1',
+        opencode: 'opencode-resume-1',
+        gemini: 'gemini-resume-1',
+      },
+    })
+
+    assert.equal(changed, true)
+    assert.equal(session.claudeSessionId, 'claude-resume-1')
+    assert.equal(session.codexThreadId, 'codex-resume-1')
+    assert.equal(session.opencodeSessionId, 'opencode-resume-1')
+    assert.equal(session.delegateResumeIds?.gemini, 'gemini-resume-1')
+  })
+})
+
+describe('dequeueNextRunnableTask', () => {
+  it('leaves blocked queued tasks in place until their dependencies are completed', () => {
+    const source = makeTask({
+      id: 'task-source',
+      title: 'Source task',
+      status: 'running',
+    })
+    const followup = makeTask({
+      id: 'task-followup',
+      title: 'Follow-up task',
+      status: 'queued',
+      blockedBy: ['task-source'],
+    })
+    const queue = ['task-followup']
+
+    const selectedWhileBlocked = dequeueNextRunnableTask(queue, {
+      [source.id]: source,
+      [followup.id]: followup,
+    })
+
+    assert.equal(selectedWhileBlocked, null)
+    assert.deepEqual(queue, ['task-followup'])
+
+    source.status = 'completed'
+    const selectedAfterUnblock = dequeueNextRunnableTask(queue, {
+      [source.id]: source,
+      [followup.id]: followup,
+    })
+
+    assert.equal(selectedAfterUnblock, 'task-followup')
+    assert.deepEqual(queue, [])
+  })
+})
+
+describe('resolveReusableTaskSessionId', () => {
+  it('reuses the completed dependency session for continuation tasks once it exists', () => {
+    const source = makeTask({
+      id: 'task-source',
+      title: 'Source task',
+      status: 'completed',
+      sessionId: 'session-source',
+      checkpoint: {
+        lastSessionId: 'session-source',
+        updatedAt: Date.now(),
+      },
+    })
+    const followup = makeTask({
+      id: 'task-followup',
+      title: 'Follow-up task',
+      status: 'queued',
+      blockedBy: ['task-source'],
+    })
+
+    const sessionId = resolveReusableTaskSessionId(
+      followup,
+      {
+        [source.id]: source,
+        [followup.id]: followup,
+      },
+      {
+        'session-source': {
+          messages: [],
+        },
+      } as SessionFixtureMap,
+    )
+
+    assert.equal(sessionId, 'session-source')
+  })
+})