@assistkick/create 1.10.0 → 1.11.0

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

@@ -1,14 +1,17 @@
 import { describe, it, mock, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { writeFileSync, mkdirSync, rmSync } from 'node:fs';
+import { AgentService } from './agent_service.js';
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
 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.',
+  model: 'claude-opus-4-6',
+  skills: '[]',
+  grounding: 'You are a test agent.',
+  defaultGrounding: null,
   projectId: null,
   isDefault: 0,
   createdAt: '2024-01-01T00:00:00Z',
@@ -18,27 +21,10 @@ const MOCK_AGENT = {
 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',
+  model: 'claude-opus-4-6',
+  skills: '["assistkick-developer"]',
+  grounding: '## CRITICAL: Data Isolation\nDeveloper grounding content',
+  defaultGrounding: '## CRITICAL: Data Isolation\nDeveloper grounding content',
   projectId: null,
   isDefault: 1,
   createdAt: '2024-01-01T00:00:00Z',
@@ -59,8 +45,6 @@ const createMockDb = () => {
     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(() => {
@@ -97,43 +81,11 @@ const createMockDb = () => {
   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) => {
+const createService = (db: any, skillsDir = '/fake/skills') => {
   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'),
-    },
+    skillsDir,
   });
 };
 
@@ -197,12 +149,15 @@ describe('AgentService', () => {
     it('creates an agent with correct fields', async () => {
       const result = await service.create({
         name: 'New Agent',
-        promptTemplate: 'You are a new agent.',
+        grounding: '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.grounding, 'You are a new agent.');
+      assert.equal(result.model, 'claude-opus-4-6');
+      assert.equal(result.skills, '[]');
+      assert.equal(result.defaultGrounding, null);
       assert.equal(result.projectId, null);
       assert.equal(result.isDefault, 0);
       assert.ok(result.createdAt);
@@ -212,12 +167,24 @@ describe('AgentService', () => {
     it('creates a project-scoped agent', async () => {
       const result = await service.create({
         name: 'Project Agent',
-        promptTemplate: 'Prompt',
+        grounding: 'Grounding content',
         projectId: 'proj_001',
       });
 
       assert.equal(result.projectId, 'proj_001');
     });
+
+    it('creates an agent with custom model and skills', async () => {
+      const result = await service.create({
+        name: 'Custom Agent',
+        grounding: 'Custom grounding',
+        model: 'claude-sonnet-4-6',
+        skills: '["assistkick-developer"]',
+      });
+
+      assert.equal(result.model, 'claude-sonnet-4-6');
+      assert.equal(result.skills, '["assistkick-developer"]');
+    });
   });
 
   describe('update', () => {
@@ -230,12 +197,24 @@ describe('AgentService', () => {
       assert.equal(db.update.mock.calls.length, 1);
     });
 
-    it('updates agent promptTemplate', async () => {
+    it('updates agent grounding', async () => {
       db._setSelectResults([[MOCK_AGENT]]);
 
-      const result = await service.update('agent-1', { promptTemplate: 'New prompt' });
+      const result = await service.update('agent-1', { grounding: 'New grounding' });
 
-      assert.equal(result.promptTemplate, 'New prompt');
+      assert.equal(result.grounding, 'New grounding');
+    });
+
+    it('updates agent model and skills', async () => {
+      db._setSelectResults([[MOCK_AGENT]]);
+
+      const result = await service.update('agent-1', {
+        model: 'claude-sonnet-4-6',
+        skills: '["assistkick-developer"]',
+      });
+
+      assert.equal(result.model, 'claude-sonnet-4-6');
+      assert.equal(result.skills, '["assistkick-developer"]');
     });
 
     it('allows editing default agents', async () => {
@@ -314,176 +293,99 @@ describe('AgentService', () => {
       );
     });
 
-    it('throws when stage cannot be inferred from name', async () => {
-      const unknownDefault = { ...MOCK_DEFAULT_AGENT, name: 'Unknown Agent' };
-      db._setSelectResults([[unknownDefault]]);
+    it('throws when default agent has no defaultGrounding', async () => {
+      const noDefaultGrounding = { ...MOCK_DEFAULT_AGENT, defaultGrounding: null };
+      db._setSelectResults([[noDefaultGrounding]]);
 
       await assert.rejects(
         () => service.resetToDefault('default-dev'),
-        { message: 'Cannot determine stage for this default agent' },
+        { message: 'No default grounding available for this agent' },
       );
     });
-  });
 
-  describe('video script writer support', () => {
-    let skillDir: string;
+    it('resets grounding to defaultGrounding value', async () => {
+      const modifiedAgent = { ...MOCK_DEFAULT_AGENT, grounding: 'User modified grounding' };
+      db._setSelectResults([[modifiedAgent]]);
 
-    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 });
-    });
+      const result = await service.resetToDefault('default-dev');
 
-    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 });
+      assert.equal(result.grounding, MOCK_DEFAULT_AGENT.defaultGrounding);
+      assert.equal(db.update.mock.calls.length, 1);
     });
   });
 
-  describe('video composition agent support', () => {
-    let skillDir: string;
+  describe('listSkills', () => {
+    let tmpDir: 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.');
+    beforeEach(async () => {
+      tmpDir = await mkdtemp(join(tmpdir(), 'skills-test-'));
     });
 
-    it('syncDefaults creates missing video composition agent', async () => {
-      const vcDb = createMockDb();
-      const vcService = createServiceWithCompositionSkill(vcDb, skillDir);
+    it('returns empty array when skills directory does not exist', async () => {
+      const svc = createService(db, '/nonexistent/path');
 
-      // No existing default agents
-      vcDb._setSelectResults([[]]);
+      const result = await svc.listSkills();
 
-      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 });
+      assert.deepEqual(result, []);
     });
 
-    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]]);
+    it('lists skills from directory with SKILL.md files', async () => {
+      const skillDir = join(tmpDir, 'my-skill');
+      await mkdir(skillDir, { recursive: true });
+      await writeFile(join(skillDir, 'SKILL.md'), '# My Skill\nDoes something useful.\nMore details here.');
 
-      await vcService.syncDefaults();
+      const svc = createService(db, tmpDir);
+      const result = await svc.listSkills();
 
-      // Should not insert any new agents
-      assert.equal(vcDb.insert.mock.calls.length, 0);
-
-      rmSync(skillDir, { recursive: true, force: true });
+      assert.equal(result.length, 1);
+      assert.equal(result[0].id, 'my-skill');
+      assert.equal(result[0].name, 'My Skill');
+      assert.ok(result[0].preview.includes('Does something useful.'));
     });
 
-    it('resetToDefault works for video composition agent', async () => {
-      const vcDb = createMockDb();
-      const vcService = createServiceWithCompositionSkill(vcDb, skillDir);
+    it('uses folder name when SKILL.md is missing', async () => {
+      const skillDir = join(tmpDir, 'bare-skill');
+      await mkdir(skillDir, { recursive: true });
 
-      vcDb._setSelectResults([[MOCK_VIDEO_COMPOSITION_AGENT]]);
+      const svc = createService(db, tmpDir);
+      const result = await svc.listSkills();
 
-      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 });
+      assert.equal(result.length, 1);
+      assert.equal(result[0].id, 'bare-skill');
+      assert.equal(result[0].name, 'bare-skill');
+      assert.equal(result[0].preview, '');
     });
 
-    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');
+    it('skips non-directory entries', async () => {
+      await writeFile(join(tmpDir, 'not-a-skill.txt'), 'ignored');
+      const skillDir = join(tmpDir, 'real-skill');
+      await mkdir(skillDir, { recursive: true });
+      await writeFile(join(skillDir, 'SKILL.md'), '# Real Skill\nA real skill.');
 
-      assert.ok(result.promptTemplate.includes('Data Isolation'));
-      assert.ok(result.promptTemplate.includes('Component Reuse'));
-      assert.ok(result.promptTemplate.includes('Work Summary'));
+      const svc = createService(db, tmpDir);
+      const result = await svc.listSkills();
 
-      rmSync(skillDir, { recursive: true, force: true });
+      assert.equal(result.length, 1);
+      assert.equal(result[0].id, 'real-skill');
     });
 
-    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]]);
+    it('truncates long previews', async () => {
+      const skillDir = join(tmpDir, 'verbose-skill');
+      await mkdir(skillDir, { recursive: true });
+      const longContent = '# Verbose Skill\n' + 'A'.repeat(300);
+      await writeFile(join(skillDir, 'SKILL.md'), longContent);
 
-      const result = await vcService.resetToDefault('default-vca');
+      const svc = createService(db, tmpDir);
+      const result = await svc.listSkills();
 
-      // Should resolve to videoCompositionAgent stage and build from skill
-      assert.ok(result.promptTemplate.includes('Video Composition Agent'));
+      assert.equal(result.length, 1);
+      assert.ok(result[0].preview.length <= 201); // 200 + ellipsis char
+      assert.ok(result[0].preview.endsWith('…'));
+    });
 
-      rmSync(skillDir, { recursive: true, force: true });
+    // Clean up temp directory after all tests in this suite
+    it('cleanup', async () => {
+      await rm(tmpDir, { recursive: true, force: true });
     });
   });
 });