- Workspace state, the "Workspace Now" block, the home briefing and the proactive handlers read the workspace's memory through server.memory: decisions are memories of kind 'decision', critical ones or ones worded as decisions; summaries list memories most important first. They no longer open workspace .mind files, so the builders are async and ProactiveContext carries `memory` instead of `getWorkspaceMindDb`. - The home briefing counts extracted personal facts that are neither confirmed nor archived as awaiting review (memory-status.ts). - Workspace routes count memories through the contract, seed template starter memories with remember() in the background (origin 'workspace-template'), export memories through list(), and deleting a workspace forgets its memory scope and clears its awareness items before the directory is removed; the delete is refused if forgetting fails. agentState.releaseWorkspace() replaces closeWorkspaceMind for callers. - The command palette searches personal memory and the active workspace's memory (UF-033). - chat.ts drops the MindDB-flake diagnostics; the mind cache they guarded no longer serves chat turns.
196 lines
6.6 KiB
TypeScript
196 lines
6.6 KiB
TypeScript
/**
|
|
* Workspace Templates API Tests
|
|
*
|
|
* Validates GET (built-in + user-created) and POST (create custom) endpoints.
|
|
* Uses the standard pattern: tmpDir + buildLocalServer + server.inject().
|
|
*/
|
|
|
|
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import os from 'node:os';
|
|
import { buildLocalServer } from '../src/local/index.js';
|
|
import type { FastifyInstance } from 'fastify';
|
|
import { injectWithAuth } from './test-utils.js';
|
|
|
|
interface TemplateResponse {
|
|
id: string;
|
|
name: string;
|
|
description: string;
|
|
persona: string;
|
|
connectors: string[];
|
|
suggestedCommands: string[];
|
|
starterMemory: string[];
|
|
builtIn: boolean;
|
|
}
|
|
|
|
describe('Workspace Templates API', () => {
|
|
let server: FastifyInstance;
|
|
let tmpDir: string;
|
|
|
|
beforeAll(async () => {
|
|
tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'waggle-ws-templates-'));
|
|
|
|
server = await buildLocalServer({ dataDir: tmpDir });
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await server.close();
|
|
try {
|
|
fs.rmSync(tmpDir, { recursive: true, force: true });
|
|
} catch {
|
|
// Non-critical — OS will clean temp dir
|
|
}
|
|
});
|
|
|
|
it('GET /api/workspace-templates returns 15 built-in templates', async () => {
|
|
const res = await injectWithAuth(server, {
|
|
method: 'GET',
|
|
url: '/api/workspace-templates',
|
|
});
|
|
|
|
expect(res.statusCode).toBe(200);
|
|
const body = JSON.parse(res.body) as { templates: TemplateResponse[]; count: number };
|
|
expect(body.templates).toBeDefined();
|
|
expect(body.count).toBe(15);
|
|
expect(body.templates.length).toBe(15);
|
|
});
|
|
|
|
it('each built-in template has all required fields', async () => {
|
|
const res = await injectWithAuth(server, {
|
|
method: 'GET',
|
|
url: '/api/workspace-templates',
|
|
});
|
|
|
|
const body = JSON.parse(res.body) as { templates: TemplateResponse[] };
|
|
for (const template of body.templates) {
|
|
expect(template.id).toBeDefined();
|
|
expect(typeof template.name).toBe('string');
|
|
expect(template.name.length).toBeGreaterThan(0);
|
|
expect(typeof template.description).toBe('string');
|
|
expect(template.description.length).toBeGreaterThan(0);
|
|
expect(typeof template.persona).toBe('string');
|
|
expect(template.persona.length).toBeGreaterThan(0);
|
|
expect(Array.isArray(template.connectors)).toBe(true);
|
|
expect(Array.isArray(template.suggestedCommands)).toBe(true);
|
|
expect(template.suggestedCommands.length).toBeGreaterThan(0);
|
|
expect(Array.isArray(template.starterMemory)).toBe(true);
|
|
// `blank` template intentionally starts with empty starterMemory;
|
|
// all other templates must seed some context.
|
|
if (template.id !== 'blank') {
|
|
expect(template.starterMemory.length).toBeGreaterThan(0);
|
|
}
|
|
expect(template.builtIn).toBe(true);
|
|
}
|
|
});
|
|
|
|
it('built-in templates have correct IDs', async () => {
|
|
const res = await injectWithAuth(server, {
|
|
method: 'GET',
|
|
url: '/api/workspace-templates',
|
|
});
|
|
|
|
const body = JSON.parse(res.body) as { templates: TemplateResponse[] };
|
|
const ids = body.templates.map(t => t.id);
|
|
expect(ids).toContain('sales-pipeline');
|
|
expect(ids).toContain('research-project');
|
|
expect(ids).toContain('code-review');
|
|
expect(ids).toContain('marketing-campaign');
|
|
expect(ids).toContain('product-launch');
|
|
expect(ids).toContain('legal-review');
|
|
});
|
|
|
|
it('built-in templates map to valid persona IDs', async () => {
|
|
// Kept in sync with BUILT_IN_TEMPLATES — expanded to 15 templates
|
|
// following the Template/Persona Architecture expansion (see CLAUDE.md §5).
|
|
const validPersonaIds = [
|
|
'researcher', 'writer', 'analyst', 'coder',
|
|
'project-manager', 'executive-assistant', 'sales-rep', 'marketer',
|
|
'support-agent', 'finance-owner', 'hr-manager', 'ops-manager',
|
|
'data-engineer', 'recruiter', 'creative-director', 'general-purpose',
|
|
];
|
|
|
|
const res = await injectWithAuth(server, {
|
|
method: 'GET',
|
|
url: '/api/workspace-templates',
|
|
});
|
|
|
|
const body = JSON.parse(res.body) as { templates: TemplateResponse[] };
|
|
for (const template of body.templates) {
|
|
expect(validPersonaIds).toContain(template.persona);
|
|
}
|
|
});
|
|
|
|
it('POST /api/workspace-templates creates a custom template', async () => {
|
|
const res = await injectWithAuth(server, {
|
|
method: 'POST',
|
|
url: '/api/workspace-templates',
|
|
payload: {
|
|
name: 'My Custom Template',
|
|
description: 'A test template for custom workflows.',
|
|
persona: 'writer',
|
|
connectors: ['slack'],
|
|
suggestedCommands: ['/draft'],
|
|
starterMemory: ['This workspace uses a custom template.'],
|
|
},
|
|
});
|
|
|
|
expect(res.statusCode).toBe(200);
|
|
const body = JSON.parse(res.body) as TemplateResponse;
|
|
expect(body.id).toMatch(/^custom-/);
|
|
expect(body.name).toBe('My Custom Template');
|
|
expect(body.description).toBe('A test template for custom workflows.');
|
|
expect(body.persona).toBe('writer');
|
|
expect(body.connectors).toEqual(['slack']);
|
|
expect(body.builtIn).toBe(false);
|
|
});
|
|
|
|
it('custom template appears in GET after POST', async () => {
|
|
const res = await injectWithAuth(server, {
|
|
method: 'GET',
|
|
url: '/api/workspace-templates',
|
|
});
|
|
|
|
const body = JSON.parse(res.body) as { templates: TemplateResponse[]; count: number };
|
|
// 15 built-in + 1 custom from previous test
|
|
expect(body.count).toBe(16);
|
|
const custom = body.templates.find(t => t.name === 'My Custom Template');
|
|
expect(custom).toBeDefined();
|
|
expect(custom!.builtIn).toBe(false);
|
|
});
|
|
|
|
it('POST /api/workspace-templates rejects missing required fields', async () => {
|
|
const res = await injectWithAuth(server, {
|
|
method: 'POST',
|
|
url: '/api/workspace-templates',
|
|
payload: {
|
|
name: 'Incomplete Template',
|
|
// missing description, persona, connectors, suggestedCommands, starterMemory
|
|
},
|
|
});
|
|
|
|
expect(res.statusCode).toBe(400);
|
|
const body = JSON.parse(res.body) as { error: string };
|
|
expect(body.error).toBeDefined();
|
|
});
|
|
|
|
it('POST /api/workspace-templates rejects invalid field types', async () => {
|
|
const res = await injectWithAuth(server, {
|
|
method: 'POST',
|
|
url: '/api/workspace-templates',
|
|
payload: {
|
|
name: 'Bad Template',
|
|
description: 'A template with bad types.',
|
|
persona: 'writer',
|
|
connectors: 'not-an-array', // should be array
|
|
suggestedCommands: ['/help'],
|
|
starterMemory: ['test'],
|
|
},
|
|
});
|
|
|
|
expect(res.statusCode).toBe(400);
|
|
const body = JSON.parse(res.body) as { error: string };
|
|
expect(body.error).toContain('connectors');
|
|
});
|
|
});
|