@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/session-tools/manage-tasks.test.ts

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-task-tool-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('manage_tasks tool', () => {
+  it('inherits continuation context from continueFromTaskId', () => {
+    const output = runWithTempDataDir(`
+      import fs from 'node:fs'
+      import path from 'node:path'
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const crudMod = await import('./src/lib/server/session-tools/crud.ts')
+      const storage = storageMod.default || storageMod
+      const crud = crudMod.default || crudMod
+
+      const now = Date.now()
+      const workspaceDir = process.env.WORKSPACE_DIR
+      const projectDir = path.join(workspaceDir, 'projects', 'project-1')
+      fs.mkdirSync(projectDir, { recursive: true })
+
+      storage.saveAgents({
+        default: {
+          id: 'default',
+          name: 'Molly',
+          description: '',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          createdAt: now,
+          updatedAt: now,
+        },
+        worker: {
+          id: 'worker',
+          name: 'Worker',
+          description: '',
+          systemPrompt: '',
+          provider: 'openai',
+          model: 'gpt-test',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+
+      storage.saveTasks({
+        'task-source': {
+          id: 'task-source',
+          title: 'Source task',
+          description: 'Original work',
+          status: 'completed',
+          agentId: 'worker',
+          projectId: 'project-1',
+          cwd: projectDir,
+          sessionId: 'session-source',
+          codexResumeId: 'codex-thread-1',
+          createdAt: now,
+          updatedAt: now,
+        },
+      })
+
+      const tools = crud.buildCrudTools({
+        cwd: workspaceDir,
+        ctx: { sessionId: 'session-creator', agentId: 'default', platformAssignScope: 'all' },
+        hasPlugin: (name) => name === 'manage_tasks',
+      })
+      const tool = tools.find((entry) => entry.name === 'manage_tasks')
+      const raw = await tool.invoke({
+        action: 'create',
+        title: 'Follow-up task',
+        description: 'Continue the previous task with the next deliverable.',
+        status: 'backlog',
+        continueFromTaskId: 'task-source',
+      })
+
+      const tasks = storage.loadTasks()
+      const created = Object.values(tasks).find((entry) => entry.id !== 'task-source')
+      console.log(JSON.stringify({ raw, created }))
+    `)
+
+    assert.equal(output.created.projectId, 'project-1')
+    assert.equal(output.created.agentId, 'worker')
+    assert.equal(output.created.sessionId, 'session-source')
+    assert.equal(output.created.codexResumeId, 'codex-thread-1')
+    assert.deepEqual(output.created.blockedBy, ['task-source'])
+  })
+})

package/src/lib/server/session-tools/memory.test.ts

@@ -0,0 +1,93 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { executeMemoryAction, shouldAutoCaptureAutonomousTurn } from './memory'
+
+describe('executeMemoryAction', () => {
+  it('defaults empty payloads to listing memories instead of reporting an unknown action', async () => {
+    const result = await executeMemoryAction({}, { agentId: 'agent-test', sessionId: 'session-test', messages: [] })
+    assert.doesNotMatch(String(result), /Unknown action/)
+    assert.equal(typeof result, 'string')
+  })
+
+  it('preserves an existing category when update omits category', async () => {
+    const scopeId = `memory-test-${Date.now()}`
+    const ctx = { agentId: scopeId, sessionId: scopeId, messages: [] }
+    const stored = await executeMemoryAction({
+      action: 'store',
+      title: `Workspace Root ${scopeId}`,
+      value: '/tmp/swarmclaw-workspace',
+      category: 'operations/environment',
+    }, ctx)
+    const memoryId = /id: ([^)]+)/.exec(String(stored))?.[1]
+    assert.ok(memoryId, `expected memory id in store result: ${stored}`)
+
+    try {
+      const updated = await executeMemoryAction({
+        action: 'update',
+        id: memoryId,
+        title: `Workspace Directory ${scopeId}`,
+      }, ctx)
+      assert.match(String(updated), /Updated memory/)
+
+      const fetched = await executeMemoryAction({ action: 'get', id: memoryId }, ctx)
+      assert.match(String(fetched), /operations\/environment\/Workspace Directory/)
+    } finally {
+      await executeMemoryAction({ action: 'delete', id: memoryId }, ctx)
+    }
+  })
+
+  it('normalizes wrapped store payloads that provide content instead of value', async () => {
+    const scopeId = `memory-test-${Date.now()}-content`
+    const ctx = { agentId: scopeId, sessionId: scopeId, messages: [] }
+
+    const result = await executeMemoryAction({
+      input: JSON.stringify({
+        action: 'store',
+        title: `Project Kodiak ${scopeId}`,
+        category: 'projects/decisions',
+        content: 'Project Kodiak uses the codename "amber-fox" and the freeze date is April 18, 2026.',
+      }),
+    }, ctx)
+
+    assert.match(String(result), /Stored memory/)
+    assert.doesNotMatch(String(result), /requires a non-empty value/i)
+  })
+
+  it('accepts common memory write aliases like note, body, text, and memory', async () => {
+    const aliases = ['note', 'body', 'text', 'memory'] as const
+
+    for (const alias of aliases) {
+      const scopeId = `memory-test-${Date.now()}-${alias}`
+      const ctx = { agentId: scopeId, sessionId: scopeId, messages: [] }
+      const result = await executeMemoryAction({
+        action: 'store',
+        title: `Alias ${alias} ${scopeId}`,
+        category: 'projects/decisions',
+        [alias]: 'Project Kodiak uses the codename "amber-fox" and the freeze date is April 21, 2026.',
+      }, ctx)
+      assert.match(String(result), /Stored memory/)
+      assert.doesNotMatch(String(result), /requires a non-empty value/i)
+    }
+  })
+
+  it('captures substantive internal autonomous turns only when tools were used', () => {
+    assert.equal(shouldAutoCaptureAutonomousTurn({
+      source: 'heartbeat-wake',
+      response: 'Inspected the failing deploy, pulled the latest logs, and identified a bad health-check path in the service config.',
+      toolEvents: [{ name: 'shell' }],
+    }), true)
+
+    assert.equal(shouldAutoCaptureAutonomousTurn({
+      source: 'heartbeat-wake',
+      response: 'HEARTBEAT_OK',
+      toolEvents: [{ name: 'shell' }],
+    }), false)
+
+    assert.equal(shouldAutoCaptureAutonomousTurn({
+      source: 'heartbeat-wake',
+      response: 'I found the issue and documented it.',
+      toolEvents: [],
+    }), false)
+  })
+})