@sprucelabs/spruce-cli 28.1.4 → 28.2.1

package/src/__tests__/behavioral/permissions/SyncingPermissions.test.ts

@@ -1,43 +1,51 @@
 import { MercuryClientFactory } from '@sprucelabs/mercury-client'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
-import { assert, test } from '@sprucelabs/test-utils'
+import { assert, generateId, test } from '@sprucelabs/test-utils'
 import ActionFactory from '../../../features/ActionFactory'
 import SyncAction, {
     SyncPermissionsOptions,
 } from '../../../features/permission/actions/SyncAction'
 import { ListPermContractsTargetAndPayload } from '../../../features/permission/stores/PermissionStore'
 import testUtil from '../../../tests/utilities/test.utility'
+import { ListSkill } from '../../support/EventFaker'
 import AbstractPermissionsTest from './support/AbstractPermissionsTest'
 import generateShortAlphaId from './support/generateShortAlphaId'
-import { sortPermissionContracts } from './support/sortPermissionContracts'
 
 export default class SyncingPermissionsTest extends AbstractPermissionsTest {
     private static syncAction: SyncAction
     private static contractId1: string
     private static contractId2: string
+    private static heartwoodSkill: ListSkill = {
+        id: generateId(),
+        slug: 'heartwood',
+        dateCreated: 0,
+        name: 'Heartwood',
+    }
 
     protected static async beforeAll() {
         await super.beforeAll()
-        this.contractId1 = generateShortAlphaId()
-        this.contractId2 = generateShortAlphaId()
+        this.contractId1 = 'b-should-be-second' + generateShortAlphaId()
+        this.contractId2 = 'a-should-be-first' + generateShortAlphaId()
     }
 
     protected static async beforeEach() {
         await super.beforeEach()
+
         this.syncAction = this.Action('permission', 'sync')
+
         MercuryClientFactory.setIsTestMode(true)
         ExecuteTrackingAction.wasExecuteInvoked = false
         await this.eventFaker.fakeListPermissionContracts()
+
+        await this.eventFaker.fakeListSkills(() => {
+            return [this.heartwoodSkill]
+        })
     }
 
     @test()
     protected static async generatesExpectedTypesFile() {
         const results = await this.sync()
-
-        const expected = this.resolveHashSprucePath(
-            `permissions/permissions.types.ts`
-        )
-
+        const expected = this.getTypesPath()
         testUtil.assertFileByPathInGeneratedFiles(expected, results.files)
     }
 
@@ -74,47 +82,42 @@ export default class SyncingPermissionsTest extends AbstractPermissionsTest {
     protected static async combinedFileImportsAllPermissions() {
         await this.createPermissionContract(this.contractId2)
 
-        const imported = await this.Service('import').importDefault(
-            this.getCombinedPath()
-        )
+        const imported = await this.import()
 
-        assert.isEqualDeep(
-            imported.sort(sortPermissionContracts),
-            [
-                {
-                    id: this.contractId1,
-                    name: this.contractId1,
-                    description: '',
-                    requireAllPermissions: false,
-                    permissions: [
-                        {
-                            id: 'can-high-five',
-                            name: 'Can give high five',
-                            description:
-                                'Will this person be allowed to high five?',
-                            defaults: { skill: false },
-                            requireAllStatuses: false,
-                        },
-                    ],
-                },
-                {
-                    id: this.contractId2,
-                    name: this.contractId2,
-                    description: '',
-                    requireAllPermissions: false,
-                    permissions: [
-                        {
-                            id: 'can-high-five',
-                            name: 'Can give high five',
-                            description:
-                                'Will this person be allowed to high five?',
-                            defaults: { skill: false },
-                            requireAllStatuses: false,
-                        },
-                    ],
-                },
-            ].sort(sortPermissionContracts)
-        )
+        assert.isEqualDeep(imported, [
+            {
+                id: this.contractId2,
+                name: this.contractId2,
+                description: '',
+                requireAllPermissions: false,
+                permissions: [
+                    {
+                        id: 'can-high-five',
+                        name: 'Can give high five',
+                        description:
+                            'Will this person be allowed to high five?',
+                        defaults: { skill: false },
+                        requireAllStatuses: false,
+                    },
+                ],
+            },
+            {
+                id: this.contractId1,
+                name: this.contractId1,
+                description: '',
+                requireAllPermissions: false,
+                permissions: [
+                    {
+                        id: 'can-high-five',
+                        name: 'Can give high five',
+                        description:
+                            'Will this person be allowed to high five?',
+                        defaults: { skill: false },
+                        requireAllStatuses: false,
+                    },
+                ],
+            },
+        ])
     }
 
     @test()
@@ -130,8 +133,11 @@ export default class SyncingPermissionsTest extends AbstractPermissionsTest {
         )
 
         await this.sync({ shouldSyncCorePermissions: true })
-        assert.isTrue(wasHit)
-        assert.isUndefined(passedTarget)
+        assert.isTrue(wasHit, 'Did not emit list-permission-contracts event')
+        assert.isUndefined(
+            passedTarget,
+            'Should not have passed a target to list-permission-contracts'
+        )
     }
 
     @test()
@@ -145,6 +151,127 @@ export default class SyncingPermissionsTest extends AbstractPermissionsTest {
         assert.isTrue(ExecuteTrackingAction.wasExecuteInvoked)
     }
 
+    @test()
+    protected static async permsSentInAlphabeticalOrder() {
+        await this.addHeartwoodAsDependency()
+        await this.fakeHeartwoodPermContracts()
+
+        await this.sync()
+        const contents = this.readTypesFile()
+
+        const firstId = contents.indexOf('perk-a-should-be-first')
+        const secondId = contents.indexOf('perk-should-be-second')
+        const thirdId = contents.indexOf('perl-a-should-be-first')
+        const fourthId = contents.indexOf('perl-should-be-second')
+        const fifthId = contents.indexOf('perm-a-should-be-first')
+        const sixthId = contents.indexOf('perm-should-be-second')
+
+        assert.isTrue(
+            firstId < secondId,
+            'Permissions are not in alphabetical order'
+        )
+
+        assert.isTrue(
+            secondId < thirdId,
+            'Permissions are not in alphabetical order'
+        )
+
+        assert.isTrue(
+            thirdId < fourthId,
+            'Permissions are not in alphabetical order'
+        )
+
+        assert.isTrue(
+            fourthId < fifthId,
+            'Permissions are not in alphabetical order'
+        )
+
+        assert.isTrue(
+            fifthId < sixthId,
+            'Permissions are not in alphabetical order'
+        )
+    }
+
+    private static async fakeHeartwoodPermContracts() {
+        await this.eventFaker.fakeListPermissionContracts(() => {
+            return [
+                {
+                    id: 'ab-' + generateShortAlphaId(),
+                    contract: {
+                        id: 'ab-' + generateShortAlphaId(),
+                        name: generateId(),
+                        permissions: [
+                            {
+                                id: 'perl-should-be-second',
+                                name: 'Should be second',
+                            },
+                            {
+                                id: 'perl-a-should-be-first',
+                                name: 'Should be first',
+                            },
+                        ],
+                    },
+                },
+                {
+                    id: 'ba-' + generateShortAlphaId(),
+                    contract: {
+                        id: 'ba-' + generateShortAlphaId(),
+                        name: generateId(),
+                        permissions: [
+                            {
+                                id: 'perm-should-be-second',
+                                name: 'Should be second',
+                            },
+                            {
+                                id: 'perm-a-should-be-first',
+                                name: 'Should be first',
+                            },
+                        ],
+                    },
+                },
+                {
+                    id: 'aa-' + generateShortAlphaId(),
+                    contract: {
+                        id: 'aa-' + generateShortAlphaId(),
+                        name: generateId(),
+                        permissions: [
+                            {
+                                id: 'perk-should-be-second',
+                                name: 'Should be second',
+                            },
+                            {
+                                id: 'perk-a-should-be-first',
+                                name: 'Should be first',
+                            },
+                        ],
+                    },
+                },
+            ]
+        })
+    }
+
+    private static async import() {
+        return await this.Service('import').importDefault(
+            this.getCombinedPath()
+        )
+    }
+
+    private static async addHeartwoodAsDependency() {
+        const results = await this.Action('dependency', 'add').execute({
+            namespace: 'heartwood',
+        })
+
+        assert.isFalsy(results.errors, 'Should not have errored')
+    }
+
+    private static readTypesFile() {
+        return diskUtil.readFile(this.getTypesPath())
+    }
+
+    private static getTypesPath() {
+        return this.resolveHashSprucePath(`permissions/permissions.types.ts`)
+    }
+
     private static getCombinedPath() {
         return this.resolveHashSprucePath('permissions', 'permissions.ts')
     }
@@ -158,7 +285,13 @@ export default class SyncingPermissionsTest extends AbstractPermissionsTest {
     }
 
     private static async sync(options?: SyncPermissionsOptions) {
-        return await this.syncAction.execute(options)
+        const results = await this.syncAction.execute(options)
+        assert.isFalsy(
+            results.errors,
+            'Should not have errored when syncing permissions'
+        )
+
+        return results
     }
 
     private static async emitDidExecuteUpgrade() {

package/src/__tests__/behavioral/{SettingRemote.test.ts → remote/SettingRemote.test.ts}

@@ -5,9 +5,9 @@ import {
     REMOTE_SANDBOX,
 } from '@sprucelabs/spruce-event-utils'
 import { test, assert } from '@sprucelabs/test-utils'
-import { FeatureCode } from '../../features/features.types'
-import TerminalInterface from '../../interfaces/TerminalInterface'
-import AbstractSkillTest from '../../tests/AbstractSkillTest'
+import { FeatureCode } from '../../../features/features.types'
+import TerminalInterface from '../../../interfaces/TerminalInterface'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
 
 export default class SettingRemoteTest extends AbstractSkillTest {
     protected static skillCacheKey = 'events'

package/src/__tests__/behavioral/remote/SettingRemoteDoesNotAskTwice.test.ts

@@ -0,0 +1,68 @@
+import { Remote } from '@sprucelabs/spruce-event-utils'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test } from '@sprucelabs/test-utils'
+import RemoteService from '../../../features/event/services/RemoteService'
+import ServiceFactory from '../../../services/ServiceFactory'
+import AbstractSkillTest from '../../../tests/AbstractSkillTest'
+
+export default class SettingRemoteDoesNotAskTwiceTest extends AbstractSkillTest {
+    protected static skillCacheKey = 'tests'
+    @test()
+    protected static async canSetRemoteWithoutOneAndOnlyBeAskedOnce() {
+        ServiceFactory.setServiceClass('remote', CountingRemoteService)
+
+        this.cleanEnv()
+
+        const promise = this.Action('event', 'setRemote', {
+            shouldAutoHandleDependencies: true,
+        }).execute({})
+
+        await this.confirmInstallSchemaFeature()
+        await this.confirmInstallPermissionFeature()
+
+        await this.confirmFinishedInstallingDependencies()
+        await this.waitForInput()
+
+        await this.ui.sendInput('local')
+
+        await promise
+    }
+
+    private static async confirmFinishedInstallingDependencies() {
+        await this.waitForInput()
+        await this.pressEnter()
+    }
+
+    private static async confirmInstallPermissionFeature() {
+        await this.waitForInput()
+        await this.pressEnter()
+    }
+
+    private static async confirmInstallSchemaFeature() {
+        await this.waitForInput()
+        await this.pressEnter()
+    }
+
+    private static async pressEnter() {
+        await this.ui.sendInput('\n')
+    }
+
+    private static cleanEnv() {
+        const envPath = this.resolvePath('.env')
+        diskUtil.deleteFile(envPath)
+        diskUtil.writeFile(envPath, 'SKILL_NAME="don\'t double me"')
+    }
+}
+
+class CountingRemoteService extends RemoteService {
+    public static wasCalled = false
+    public set(host: Remote) {
+        if (CountingRemoteService.wasCalled) {
+            throw new Error('Called twice')
+        }
+
+        super.set(host)
+
+        CountingRemoteService.wasCalled = true
+    }
+}

package/src/__tests__/behavioral/tests/CreatingATest.test.ts

@@ -43,7 +43,7 @@ export default class CreatingBehavioralTestsTest extends AbstractTestTest {
 
         await assert.doesThrowAsync(
             () => this.Service('command').execute('yarn test'),
-            /false.*?does not equal.*?true/gis
+            /Expected:.*?false/gis
         )
     }
 

package/src/__tests__/behavioral/tests/SelectingAnAbstractTestClass.test.ts

@@ -204,7 +204,7 @@ export default class SelectingAnAbstractTestClassTest extends AbstractTestTest {
 
         await assert.doesThrowAsync(
             () => this.Service('command').execute('yarn test'),
-            /false.*?does not equal.*?true/gis
+            /Expected: false/gis
         )
     }
 

package/src/__tests__/behavioral/tests/TestingDataStores.test.ts

@@ -75,11 +75,19 @@ export default class TestingDataStoresTest extends AbstractSkillTest {
             shouldReportWhileRunning: false,
         })
 
-        assert.isArray(testResults.errors)
-        assert.isLength(testResults.errors, 1)
+        assert.isArray(testResults.errors, 'should have returned errors')
+        assert.isLength(
+            testResults.errors,
+            1,
+            'should have only returned 1 error'
+        )
 
         const first = testResults.errors[0]
 
-        assert.doesInclude(first.message, 'does not equal')
+        assert.doesInclude(
+            first.message,
+            'Expected:',
+            'should have failed the test'
+        )
     }
 }

package/src/__tests__/support/EventFaker.ts

@@ -4,6 +4,14 @@ import { generateId } from '@sprucelabs/test-utils'
 import { ListPermContractsTargetAndPayload } from '../../features/permission/stores/PermissionStore'
 
 export default class EventFaker {
+    public async fakeListSkills(cb?: () => void | ListSkill[]) {
+        await eventFaker.on('list-skills::v2020_12_25', () => {
+            return {
+                skills: cb?.() ?? [],
+            }
+        })
+    }
+
     public async fakeListPermissionContracts(
         cb?: (
             targetAndPayload: ListPermContractsTargetAndPayload
@@ -42,3 +50,5 @@ export default class EventFaker {
         })
     }
 }
+
+export type ListSkill = SpruceSchemas.Mercury.v2020_12_25.ListSkillsSkill

package/src/errors/SpruceError.ts

@@ -277,6 +277,10 @@ export default class SpruceError extends AbstractSpruceError<ErrorOptions> {
                 message = `You already have an AppController! Run \`spruce sync.views\` if you are having issues.`
                 break
 
+            case 'AGENT_ALREADY_REGISTERED':
+                message = `You already registerd an AI Agent at ${options.promptPath}. If you want to register a new one, delete that file first.`
+                break
+
             default:
                 message = super.friendlyMessage()
         }

package/src/errors/agentAlreadyRegistered.builder.ts

@@ -0,0 +1,14 @@
+import { buildErrorSchema } from '@sprucelabs/schema'
+
+export default buildErrorSchema({
+    id: 'agentAlreadyRegistered',
+    name: 'agent already registered',
+    fields: {
+        promptPath: {
+            type: 'text',
+            isRequired: true,
+            label: 'Prompt Path',
+            hint: 'The path to the existing agent prompt file.',
+        },
+    },
+})

package/src/features/ActionExecuter.ts

@@ -1,3 +1,4 @@
+import { Schema } from '@sprucelabs/schema'
 import { eventResponseUtil } from '@sprucelabs/spruce-event-utils'
 import merge from 'lodash/merge'
 import SpruceError from '../errors/SpruceError'
@@ -40,8 +41,8 @@ export default class ActionExecuter {
     private async execute(options: {
         featureCode: FeatureCode
         actionCode: string
-        action: any
-        originalExecute: any
+        action: FeatureAction<Schema>
+        originalExecute: FeatureAction<Schema>['execute']
         options?: Record<string, any>
     }): Promise<FeatureInstallResponse & FeatureActionResponse> {
         const {
@@ -187,7 +188,7 @@ export default class ActionExecuter {
 
         const originalExecute = action.execute.bind(action)
 
-        action.execute = async (options: any) => {
+        action.execute = async (options: Record<string, any>) => {
             return this.execute({
                 featureCode,
                 actionCode,
@@ -197,7 +198,7 @@ export default class ActionExecuter {
             })
         }
 
-        return action as any
+        return action as FeatureAction<Schema>
     }
 }
 

package/src/features/FeatureInstallerFactory.ts

@@ -6,6 +6,7 @@ import { ApiClientFactory } from '../types/apiClient.types'
 import { GraphicsInterface } from '../types/cli.types'
 import { FeatureOptions } from './AbstractFeature'
 import ActionExecuter from './ActionExecuter'
+import AgentFeature from './agent/AgentFeature'
 import CacheFeature from './cache/CacheFeature'
 import ConversationFeature from './conversation/ConversationFeature'
 import DependencyFeature from './dependencies/DependencyFeature'
@@ -55,6 +56,7 @@ export default class FeatureInstallerFactory {
         DependencyFeature,
         PolishFeature,
         PermissionFeature,
+        AgentFeature,
     ]
 
     public static readonly featureCodes: FeatureCode[] = [
@@ -80,6 +82,7 @@ export default class FeatureInstallerFactory {
         'dependency',
         'polish',
         'permission',
+        'agent',
     ]
 
     public static WithAllFeatures(

package/src/features/agent/AgentFeature.ts

@@ -0,0 +1,31 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { FileDescription } from '../../types/cli.types'
+import AbstractFeature, { FeatureDependency } from '../AbstractFeature'
+import { FeatureCode } from '../features.types'
+
+export default class AgentFeature extends AbstractFeature {
+    public description = 'AI Agent support for your skill.'
+    public code: FeatureCode = 'agent'
+    public nameReadable = 'Agent'
+    public actionsDir = diskUtil.resolvePath(__dirname, 'actions')
+    public dependencies: FeatureDependency[] = [
+        { code: 'event', isRequired: true },
+    ]
+    public packageDependencies = [
+        {
+            name: '@sprucelabs/spruce-agent-plugin',
+        },
+    ]
+
+    public readonly fileDescriptions: FileDescription[] = []
+}
+
+declare module '../../features/features.types' {
+    interface FeatureMap {
+        agent: AgentFeature
+    }
+
+    interface FeatureOptionsMap {
+        agent: undefined
+    }
+}

package/src/features/agent/actions/RegisterAction.ts

@@ -0,0 +1,79 @@
+import { buildSchema, SchemaValues } from '@sprucelabs/schema'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import SpruceError from '../../../errors/SpruceError'
+import AbstractAction from '../../AbstractAction'
+import { FeatureActionResponse } from '../../features.types'
+
+const optionsSchema = buildSchema({
+    id: 'registerAgentOptions',
+    description:
+        'Turn Sprucebot into an agent of your own design. Heck, even give him a new name! You can create a Platform Agent or a Skill Agent. Skill Agent coming soon...',
+    fields: {
+        type: {
+            label: 'Agent Type',
+            type: 'select',
+            hint: 'You can only create a System Agent if you have permission to do so...',
+            options: {
+                choices: [
+                    {
+                        value: 'system',
+                        label: 'System Agent',
+                    },
+                    {
+                        value: 'skill',
+                        label: 'Skill Agent (coming soon)',
+                    },
+                ],
+            },
+        },
+        name: {
+            type: 'text',
+            label: 'Agent Name',
+            isRequired: true,
+        },
+    },
+})
+
+type OptionsSchema = typeof optionsSchema
+type Options = SchemaValues<OptionsSchema>
+
+export default class RegisterAction extends AbstractAction<OptionsSchema> {
+    public optionsSchema = optionsSchema
+    public invocationMessage = 'Registering your AI Agent... 🤖'
+
+    public async execute(options: Options): Promise<FeatureActionResponse> {
+        const { name } = this.validateAndNormalizeOptions(options)
+
+        const writer = this.Writer('agent')
+        const promptPath = writer.resolveSystemPromptPath(this.cwd)
+        if (diskUtil.doesFileExist(promptPath)) {
+            return {
+                errors: [
+                    new SpruceError({
+                        code: 'AGENT_ALREADY_REGISTERED',
+                        promptPath,
+                    }),
+                ],
+            }
+        }
+        const plugin = await writer.writePlugin(this.cwd)
+        const prompt = await writer.writeSystemPrompt(this.cwd, {
+            name,
+        })
+
+        return {
+            headline: `AI Agent ${name} Registered Successfully!`,
+            summaryLines: [
+                `Registered ${name} AI Agent!`,
+                `Agent name: ${name}`,
+            ],
+            hints: [
+                'Next steps:',
+                ' - Customize your agent prompt in agents/SYSTEM_PROMPT.md',
+                ' - Boot your skill',
+                ' - Message the agent (try responding to the pin code email/text)',
+            ],
+            files: [...plugin, ...prompt],
+        }
+    }
+}

package/src/features/agent/stores/AgentStore.ts

@@ -0,0 +1,16 @@
+import AbstractStore from '../../../stores/AbstractStore'
+
+export default class AgentStore extends AbstractStore {
+    public name = 'agent'
+
+    public async getPlatformAgent() {
+        const client = await this.connectToApi({
+            shouldAuthAsCurrentSkill: true,
+        })
+        const [{ agent }] = await client.emitAndFlattenResponses(
+            'get-agent::v2020_12_25'
+        )
+
+        return agent
+    }
+}