@assistkick/create 1.6.0 → 1.8.0

package/templates/assistkick-product-system/packages/backend/src/services/agent_service.test.ts

@@ -0,0 +1,489 @@
+import { describe, it, mock, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { AgentService } from './agent_service.ts';
+
+const MOCK_AGENT = {
+  id: 'agent-1',
+  name: 'Test Agent',
+  promptTemplate: 'You are a test agent.',
+  projectId: null,
+  isDefault: 0,
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+};
+
+const MOCK_DEFAULT_AGENT = {
+  id: 'default-dev',
+  name: 'Default Developer',
+  promptTemplate: 'Original prompt template',
+  projectId: null,
+  isDefault: 1,
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+};
+
+const MOCK_VIDEO_SCRIPT_AGENT = {
+  id: 'default-vsw',
+  name: 'Default Video Script Writer',
+  promptTemplate: 'Original video script prompt',
+  projectId: null,
+  isDefault: 1,
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+};
+
+const MOCK_VIDEO_COMPOSITION_AGENT = {
+  id: 'default-vca',
+  name: 'Default Video Composition Agent',
+  promptTemplate: 'Original video composition prompt',
+  projectId: null,
+  isDefault: 1,
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+};
+
+const createMockDb = () => {
+  let selectResults: any[][] = [];
+  let selectCallIndex = 0;
+
+  const getNextResult = () => {
+    const result = selectResults[selectCallIndex] || [];
+    selectCallIndex++;
+    return result;
+  };
+
+  const db = {
+    select: mock.fn(() => {
+      const selectObj = {
+        from: mock.fn(() => {
+          // Make from() return a thenable (for direct await without .where())
+          // that also has .where() and .leftJoin() for chaining
+          const result = getNextResult();
+          const fromObj = Object.assign(Promise.resolve(result), {
+            where: mock.fn(() => {
+              return result;
+            }),
+            leftJoin: mock.fn(() => ({
+              where: mock.fn(() => {
+                return getNextResult();
+              }),
+            })),
+          });
+          return fromObj;
+        }),
+      };
+      return selectObj;
+    }),
+    insert: mock.fn(() => ({
+      values: mock.fn(() => Promise.resolve()),
+    })),
+    update: mock.fn(() => ({
+      set: mock.fn(() => ({
+        where: mock.fn(() => Promise.resolve()),
+      })),
+    })),
+    delete: mock.fn(() => ({
+      where: mock.fn(() => Promise.resolve()),
+    })),
+    _setSelectResults: (results: any[][]) => {
+      selectResults = results;
+      selectCallIndex = 0;
+    },
+  };
+
+  return db;
+};
+
+const createService = (db: any) => {
+  return new AgentService({
+    getDb: () => db,
+    log: mock.fn(),
+    skillPaths: {
+      developer: '/fake/developer/SKILL.md',
+      reviewer: '/fake/reviewer/SKILL.md',
+      debugger: '/fake/debugger/SKILL.md',
+    },
+  });
+};
+
+/** Create a service with a real skill file for the video script writer. */
+const createServiceWithVideoSkill = (db: any, skillDir: string) => {
+  return new AgentService({
+    getDb: () => db,
+    log: mock.fn(),
+    skillPaths: {
+      developer: '/fake/developer/SKILL.md',
+      reviewer: '/fake/reviewer/SKILL.md',
+      debugger: '/fake/debugger/SKILL.md',
+      videoScriptWriter: join(skillDir, 'SKILL.md'),
+    },
+  });
+};
+
+/** Create a service with a real skill file for the video composition agent. */
+const createServiceWithCompositionSkill = (db: any, skillDir: string) => {
+  return new AgentService({
+    getDb: () => db,
+    log: mock.fn(),
+    skillPaths: {
+      developer: '/fake/developer/SKILL.md',
+      reviewer: '/fake/reviewer/SKILL.md',
+      debugger: '/fake/debugger/SKILL.md',
+      videoCompositionAgent: join(skillDir, 'SKILL.md'),
+    },
+  });
+};
+
+describe('AgentService', () => {
+  let db: ReturnType<typeof createMockDb>;
+  let service: AgentService;
+
+  beforeEach(() => {
+    db = createMockDb();
+    service = createService(db);
+  });
+
+  describe('listAgents', () => {
+    it('returns global agents when scope is global', async () => {
+      db._setSelectResults([[MOCK_AGENT, MOCK_DEFAULT_AGENT]]);
+
+      const result = await service.listAgents('global');
+
+      assert.equal(result.length, 2);
+      assert.equal(db.select.mock.calls.length, 1);
+    });
+
+    it('returns project-scoped agents', async () => {
+      const projectAgent = { ...MOCK_AGENT, projectId: 'proj_001' };
+      db._setSelectResults([[projectAgent]]);
+
+      const result = await service.listAgents('project', 'proj_001');
+
+      assert.equal(result.length, 1);
+      assert.equal(result[0].projectId, 'proj_001');
+    });
+
+    it('throws when project scope without projectId', async () => {
+      await assert.rejects(
+        () => service.listAgents('project'),
+        { message: 'projectId is required for project scope' },
+      );
+    });
+  });
+
+  describe('getById', () => {
+    it('returns agent when found', async () => {
+      db._setSelectResults([[MOCK_AGENT]]);
+
+      const result = await service.getById('agent-1');
+
+      assert.ok(result);
+      assert.equal(result.name, 'Test Agent');
+    });
+
+    it('returns null when not found', async () => {
+      db._setSelectResults([[]]);
+
+      const result = await service.getById('nonexistent');
+
+      assert.equal(result, null);
+    });
+  });
+
+  describe('create', () => {
+    it('creates an agent with correct fields', async () => {
+      const result = await service.create({
+        name: 'New Agent',
+        promptTemplate: 'You are a new agent.',
+      });
+
+      assert.ok(result.id);
+      assert.equal(result.name, 'New Agent');
+      assert.equal(result.promptTemplate, 'You are a new agent.');
+      assert.equal(result.projectId, null);
+      assert.equal(result.isDefault, 0);
+      assert.ok(result.createdAt);
+      assert.equal(db.insert.mock.calls.length, 1);
+    });
+
+    it('creates a project-scoped agent', async () => {
+      const result = await service.create({
+        name: 'Project Agent',
+        promptTemplate: 'Prompt',
+        projectId: 'proj_001',
+      });
+
+      assert.equal(result.projectId, 'proj_001');
+    });
+  });
+
+  describe('update', () => {
+    it('updates agent name', async () => {
+      db._setSelectResults([[MOCK_AGENT]]);
+
+      const result = await service.update('agent-1', { name: 'Updated Name' });
+
+      assert.equal(result.name, 'Updated Name');
+      assert.equal(db.update.mock.calls.length, 1);
+    });
+
+    it('updates agent promptTemplate', async () => {
+      db._setSelectResults([[MOCK_AGENT]]);
+
+      const result = await service.update('agent-1', { promptTemplate: 'New prompt' });
+
+      assert.equal(result.promptTemplate, 'New prompt');
+    });
+
+    it('allows editing default agents', async () => {
+      db._setSelectResults([[MOCK_DEFAULT_AGENT]]);
+
+      const result = await service.update('default-dev', { name: 'Custom Developer' });
+
+      assert.equal(result.name, 'Custom Developer');
+    });
+
+    it('throws when agent not found', async () => {
+      db._setSelectResults([[]]);
+
+      await assert.rejects(
+        () => service.update('nonexistent', { name: 'X' }),
+        { message: 'Agent not found' },
+      );
+    });
+  });
+
+  describe('delete', () => {
+    it('deletes a non-default, unreferenced agent', async () => {
+      // First call: getById, second call: workflows list (empty)
+      db._setSelectResults([[MOCK_AGENT], []]);
+
+      await service.delete('agent-1');
+
+      assert.equal(db.delete.mock.calls.length, 1);
+    });
+
+    it('throws when agent not found', async () => {
+      db._setSelectResults([[]]);
+
+      await assert.rejects(
+        () => service.delete('nonexistent'),
+        { message: 'Agent not found' },
+      );
+    });
+
+    it('throws when deleting a default agent', async () => {
+      db._setSelectResults([[MOCK_DEFAULT_AGENT]]);
+
+      await assert.rejects(
+        () => service.delete('default-dev'),
+        { message: 'Cannot delete a default agent' },
+      );
+    });
+
+    it('throws when agent is referenced in a workflow', async () => {
+      const workflow = { id: 'wf-1', graphData: '{"nodes":[{"data":{"agentId":"agent-1"}}]}' };
+      db._setSelectResults([[MOCK_AGENT], [workflow]]);
+
+      await assert.rejects(
+        () => service.delete('agent-1'),
+        { message: 'Cannot delete an agent that is referenced in a workflow' },
+      );
+    });
+  });
+
+  describe('resetToDefault', () => {
+    it('throws when agent not found', async () => {
+      db._setSelectResults([[]]);
+
+      await assert.rejects(
+        () => service.resetToDefault('nonexistent'),
+        { message: 'Agent not found' },
+      );
+    });
+
+    it('throws when agent is not a default agent', async () => {
+      db._setSelectResults([[MOCK_AGENT]]);
+
+      await assert.rejects(
+        () => service.resetToDefault('agent-1'),
+        { message: 'Only default agents can be reset' },
+      );
+    });
+
+    it('throws when stage cannot be inferred from name', async () => {
+      const unknownDefault = { ...MOCK_DEFAULT_AGENT, name: 'Unknown Agent' };
+      db._setSelectResults([[unknownDefault]]);
+
+      await assert.rejects(
+        () => service.resetToDefault('default-dev'),
+        { message: 'Cannot determine stage for this default agent' },
+      );
+    });
+  });
+
+  describe('video script writer support', () => {
+    let skillDir: string;
+
+    beforeEach(() => {
+      skillDir = join(tmpdir(), `agent-test-${Date.now()}`);
+      mkdirSync(skillDir, { recursive: true });
+      writeFileSync(join(skillDir, 'SKILL.md'), '# Video Script Writer\nTest skill content.');
+    });
+
+    it('syncDefaults creates missing video script writer agent', async () => {
+      const vsDb = createMockDb();
+      const vsService = createServiceWithVideoSkill(vsDb, skillDir);
+
+      // syncDefaults queries isDefault=1 agents — return empty (no existing defaults)
+      vsDb._setSelectResults([[]]);
+
+      await vsService.syncDefaults();
+
+      // Should have called insert for all 4 default agents whose skill path exists
+      // developer/reviewer/debugger will fail because /fake/ doesn't exist
+      // only videoScriptWriter should succeed
+      assert.equal(vsDb.insert.mock.calls.length, 1);
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+
+    it('syncDefaults skips video script writer when it already exists', async () => {
+      const vsDb = createMockDb();
+      const vsService = createServiceWithVideoSkill(vsDb, skillDir);
+
+      // syncDefaults finds the video script writer already in DB
+      vsDb._setSelectResults([[MOCK_VIDEO_SCRIPT_AGENT]]);
+
+      await vsService.syncDefaults();
+
+      // Should not insert any new agents (video script writer exists, others fail due to /fake/ path)
+      assert.equal(vsDb.insert.mock.calls.length, 0);
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+
+    it('resetToDefault works for video script writer agent', async () => {
+      const vsDb = createMockDb();
+      const vsService = createServiceWithVideoSkill(vsDb, skillDir);
+
+      vsDb._setSelectResults([[MOCK_VIDEO_SCRIPT_AGENT]]);
+
+      const result = await vsService.resetToDefault('default-vsw');
+
+      assert.ok(result.promptTemplate.includes('Video Script Writer'));
+      assert.ok(result.promptTemplate.includes('{{featureDescription}}'));
+      assert.ok(result.promptTemplate.includes('{{compositionName}}'));
+      assert.ok(result.promptTemplate.includes('{{worktreePath}}'));
+      assert.ok(result.promptTemplate.includes('{{iterationComments}}'));
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+
+    it('template includes fenced directive format documentation', async () => {
+      const vsDb = createMockDb();
+      const vsService = createServiceWithVideoSkill(vsDb, skillDir);
+
+      vsDb._setSelectResults([[MOCK_VIDEO_SCRIPT_AGENT]]);
+
+      const result = await vsService.resetToDefault('default-vsw');
+
+      // The SKILL.md mentions fenced directives; template sections add task context
+      assert.ok(result.promptTemplate.includes('Data Isolation'));
+      assert.ok(result.promptTemplate.includes('Work Summary'));
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('video composition agent support', () => {
+    let skillDir: string;
+
+    beforeEach(() => {
+      skillDir = join(tmpdir(), `agent-composition-test-${Date.now()}`);
+      mkdirSync(skillDir, { recursive: true });
+      writeFileSync(join(skillDir, 'SKILL.md'), '# Video Composition Agent\nTest composition skill content.');
+    });
+
+    it('syncDefaults creates missing video composition agent', async () => {
+      const vcDb = createMockDb();
+      const vcService = createServiceWithCompositionSkill(vcDb, skillDir);
+
+      // No existing default agents
+      vcDb._setSelectResults([[]]);
+
+      await vcService.syncDefaults();
+
+      // Only videoCompositionAgent should succeed (others have /fake/ paths)
+      assert.equal(vcDb.insert.mock.calls.length, 1);
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+
+    it('syncDefaults skips video composition agent when it already exists', async () => {
+      const vcDb = createMockDb();
+      const vcService = createServiceWithCompositionSkill(vcDb, skillDir);
+
+      // Video composition agent already in DB
+      vcDb._setSelectResults([[MOCK_VIDEO_COMPOSITION_AGENT]]);
+
+      await vcService.syncDefaults();
+
+      // Should not insert any new agents
+      assert.equal(vcDb.insert.mock.calls.length, 0);
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+
+    it('resetToDefault works for video composition agent', async () => {
+      const vcDb = createMockDb();
+      const vcService = createServiceWithCompositionSkill(vcDb, skillDir);
+
+      vcDb._setSelectResults([[MOCK_VIDEO_COMPOSITION_AGENT]]);
+
+      const result = await vcService.resetToDefault('default-vca');
+
+      assert.ok(result.promptTemplate.includes('Video Composition Agent'));
+      assert.ok(result.promptTemplate.includes('{{featureDescription}}'));
+      assert.ok(result.promptTemplate.includes('{{compositionName}}'));
+      assert.ok(result.promptTemplate.includes('{{worktreePath}}'));
+      assert.ok(result.promptTemplate.includes('{{iterationComments}}'));
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+
+    it('template includes composition-specific sections', async () => {
+      const vcDb = createMockDb();
+      const vcService = createServiceWithCompositionSkill(vcDb, skillDir);
+
+      vcDb._setSelectResults([[MOCK_VIDEO_COMPOSITION_AGENT]]);
+
+      const result = await vcService.resetToDefault('default-vca');
+
+      assert.ok(result.promptTemplate.includes('Data Isolation'));
+      assert.ok(result.promptTemplate.includes('Component Reuse'));
+      assert.ok(result.promptTemplate.includes('Work Summary'));
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+
+    it('inferStageFromName correctly identifies video composition agent', async () => {
+      const vcDb = createMockDb();
+      const vcService = createServiceWithCompositionSkill(vcDb, skillDir);
+
+      // Test with a custom-named agent that includes "video composition"
+      const customAgent = { ...MOCK_VIDEO_COMPOSITION_AGENT, name: 'Custom Video Composition Bot' };
+      vcDb._setSelectResults([[customAgent]]);
+
+      const result = await vcService.resetToDefault('default-vca');
+
+      // Should resolve to videoCompositionAgent stage and build from skill
+      assert.ok(result.promptTemplate.includes('Video Composition Agent'));
+
+      rmSync(skillDir, { recursive: true, force: true });
+    });
+  });
+});