@sprucelabs/spruce-cli 28.2.3 → 29.0.1

package/src/features/schema/utilities/schemaDisk.utility.ts

@@ -1,6 +1,10 @@
 import pathUtil from 'path'
 import { Schema, SchemaError, SchemaTemplateItem } from '@sprucelabs/schema'
-import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
+import {
+    diskUtil,
+    namesUtil,
+    ProjectLanguage,
+} from '@sprucelabs/spruce-skill-utils'
 import schemaGeneratorUtil from './schemaGenerator.utility'
 
 const schemaDiskUtil = {
@@ -8,25 +12,29 @@ const schemaDiskUtil = {
         destination: string
         schema: Schema
         shouldIncludeFileExtension?: boolean
+        language?: ProjectLanguage
     }) {
-        const {
-            destination,
-            schema,
-            shouldIncludeFileExtension: includeFileExtension,
-        } = options
+        const { destination, schema, shouldIncludeFileExtension, language } =
+            options
 
         if (!schema.namespace) {
             throw new SchemaError({
                 code: 'MISSING_PARAMETERS',
                 parameters: ['namespace'],
+                friendlyMessage: `Schema with id "${schema.id}" is missing a namespace so it can not be written to disk.`,
             })
         }
 
+        const name =
+            language == 'go'
+                ? `${namesUtil.toSnake(schema.id)}.go`
+                : `${schema.id}.schema${shouldIncludeFileExtension === false ? '' : '.ts'}`
+
         return pathUtil.join(
             destination,
             namesUtil.toCamel(schema.namespace),
             schema.version ?? '',
-            `${schema.id}.schema${includeFileExtension === false ? '' : '.ts'}`
+            name
         )
     },
 
@@ -35,23 +43,32 @@ const schemaDiskUtil = {
         generateStandaloneTypesFile: boolean
         schemaTypesDestinationDirOrFile: string
         fieldTypesDestinationDir: string
+        language: ProjectLanguage
     }) {
-        const {
+        let {
             cwd,
             generateStandaloneTypesFile,
             schemaTypesDestinationDirOrFile,
             fieldTypesDestinationDir,
+            language,
         } = options
 
+        if (
+            language === 'go' &&
+            !generateStandaloneTypesFile &&
+            schemaTypesDestinationDirOrFile === '#spruce/schemas'
+        ) {
+            schemaTypesDestinationDirOrFile = 'schemas/schemas.go'
+        }
+
         const resolvedSchemaTypesDestination = diskUtil.resolvePath(
             cwd,
             generateStandaloneTypesFile &&
                 diskUtil.isDirPath(schemaTypesDestinationDirOrFile)
-                ? diskUtil.resolvePath(
+                ? this.resolveStandaloneSchemaTypesFilePath({
                       cwd,
                       schemaTypesDestinationDirOrFile,
-                      'core.schemas.types.ts'
-                  )
+                  })
                 : schemaTypesDestinationDirOrFile
         )
 
@@ -73,6 +90,21 @@ const schemaDiskUtil = {
         }
     },
 
+    resolveStandaloneSchemaTypesFilePath(options: {
+        cwd: string
+        schemaTypesDestinationDirOrFile: string
+    }) {
+        const { cwd, schemaTypesDestinationDirOrFile } = options
+
+        return diskUtil.resolvePath(
+            cwd,
+            schemaTypesDestinationDirOrFile,
+            diskUtil.detectProjectLanguage(cwd) === 'go'
+                ? '../../schemas/core_schemas.go'
+                : 'core.schemas.types.ts'
+        )
+    },
+
     async deleteOrphanedSchemas(
         resolvedDestination: string,
         schemaTemplateItems: SchemaTemplateItem[]

package/src/features/schema/utilities/schemaGenerator.utility.ts

@@ -7,26 +7,27 @@ const schemaGeneratorUtil = {
         lookupDir: string,
         schemas: { id: string; namespace?: string; version?: string }[]
     ): Promise<string[]> {
-        const matches = await globby(
-            pathUtil.join(lookupDir, '/**/*.schema.[t|j]s')
-        )
+        const matches = await globby([
+            pathUtil.join(lookupDir, '/**/*.schema.[t|j]s'),
+            pathUtil.join(lookupDir, '/*/v*/*.go'),
+        ])
+
         const filtered = matches.filter((match) => {
             let found = false
 
             for (const schema of schemas) {
                 const { id, namespace, version } = schema
-                let regexString = `${pathUtil.sep}${id}.schema.[t|j]s`
 
-                if (version) {
-                    regexString = pathUtil.sep + version + regexString
-                }
+                const expectedPath = match.endsWith('.go')
+                    ? this.buildPath(
+                          namesUtil.toSnake(id),
+                          '.go',
+                          namespace,
+                          version
+                      )
+                    : this.buildPath(id, '.schema.', namespace, version)
 
-                if (namespace) {
-                    regexString = namesUtil.toCamel(namespace) + regexString
-                }
-
-                const idx = match.search(new RegExp(regexString))
-                if (idx > -1) {
+                if (match.includes(expectedPath)) {
                     found = true
                     break
                 }
@@ -36,6 +37,25 @@ const schemaGeneratorUtil = {
         })
         return filtered
     },
+
+    buildPath(
+        schemaId: string,
+        suffix: string,
+        namespace?: string,
+        version?: string
+    ): string {
+        let path = pathUtil.sep + schemaId + suffix
+
+        if (version) {
+            path = pathUtil.sep + version + path
+        }
+
+        if (namespace) {
+            path = namesUtil.toCamel(namespace) + path
+        }
+
+        return path
+    },
 }
 
 export default schemaGeneratorUtil

package/src/features/schema/writers/SchemaWriter.ts

@@ -1,7 +1,7 @@
 import path from 'path'
 import pathUtil from 'path'
 import { FieldTemplateItem, SchemaTemplateItem } from '@sprucelabs/schema'
-import { versionUtil } from '@sprucelabs/spruce-skill-utils'
+import { ProjectLanguage, versionUtil } from '@sprucelabs/spruce-skill-utils'
 import { diskUtil } from '@sprucelabs/spruce-skill-utils'
 import {
     LATEST_HANDLEBARS,
@@ -110,13 +110,17 @@ export default class SchemaWriter extends AbstractWriter {
 
     public async writeSchemasAndTypes(
         destinationDirOrFilename: string,
-        options: GenerateSchemaTypesOptions
+        options: Omit<GenerateSchemaTypesOptions, 'valueTypes'> & {
+            valueTypes?: ValueTypes
+            goModuleNameAndPath?: string
+        }
     ): Promise<WriteResults> {
         const {
             fieldTemplateItems,
             schemaTemplateItems,
             valueTypes,
             typesTemplate,
+            language,
         } = options
 
         this.isLintEnabled = false
@@ -132,7 +136,8 @@ export default class SchemaWriter extends AbstractWriter {
         const localItems = schemaTemplateItems.filter((i) => !i.importFrom)
 
         if (localItems.length > 0) {
-            const schemaTypesContents = this.templates.schemasTypes({
+            let schemaTypesContents = this.templates.schemasTypes({
+                language: language === 'go' ? 'go' : 'typescript',
                 schemaTemplateItems: localItems,
                 fieldTemplateItems,
                 valueTypes,
@@ -140,6 +145,17 @@ export default class SchemaWriter extends AbstractWriter {
                 typesTemplate,
             })
 
+            if (language === 'go') {
+                const referencesSchemaType =
+                    schemaTypesContents.split('SpruceSchema.')
+                if (referencesSchemaType.length === 1) {
+                    schemaTypesContents = schemaTypesContents.replace(
+                        'import SpruceSchema "github.com/sprucelabsai-community/spruce-schema/v32/pkg/fields"',
+                        ''
+                    )
+                }
+            }
+
             results = await this.writeFileIfChangedMixinResults(
                 resolvedTypesDestination,
                 schemaTypesContents,
@@ -154,7 +170,7 @@ export default class SchemaWriter extends AbstractWriter {
         const allSchemaResults = await this.writeAllSchemas(
             pathUtil.dirname(resolvedTypesDestination),
             {
-                ...options,
+                ...(options as GenerateSchemaTypesOptions),
                 typesFile: resolvedTypesDestination,
             }
         )
@@ -172,52 +188,61 @@ export default class SchemaWriter extends AbstractWriter {
         destinationDir: string,
         options: GenerateSchemaTypesOptions & { typesFile?: string }
     ): Promise<WriteResults> {
+        const { language } = options
         const results: WriteResults = []
 
         for (const item of options.schemaTemplateItems) {
-            const schemaResults = await this.writeSchema(destinationDir, {
-                ...options,
-                ...item,
-            })
-            results.push(...schemaResults)
+            if (language === 'ts' || (language === 'go' && !item.importFrom)) {
+                const schemaResults = await this.writeSchema(destinationDir, {
+                    ...options,
+                    ...item,
+                })
+                results.push(...schemaResults)
+            }
         }
 
         return results
     }
 
-    public async writeSchema(
+    private async writeSchema(
         destinationDir: string,
         options: {
             schemaTemplateItems: SchemaTemplateItem[]
             fieldTemplateItems: FieldTemplateItem[]
             valueTypes: ValueTypes
             typesFile?: string
+            language?: ProjectLanguage
             registerBuiltSchemas?: boolean
+            goModuleNameAndPath?: string
             shouldImportCoreSchemas: boolean
         } & SchemaTemplateItem
     ) {
-        const {
+        let {
             schemaTemplateItems,
             fieldTemplateItems,
             valueTypes,
             registerBuiltSchemas = true,
+            language,
+            schema,
+            typesFile,
             ...item
         } = options
 
         const resolvedDestination = schemaDiskUtil.resolvePath({
             destination: destinationDir,
-            schema: options.schema,
+            schema,
+            language,
         })
 
-        let typesFile = options.typesFile
-            ? diskUtil.resolveRelativePath(
-                  pathUtil.dirname(resolvedDestination),
-                  options.typesFile
-              )
-            : undefined
+        typesFile = this.resolveTypesFile(typesFile, resolvedDestination)
 
-        if (typesFile) {
-            typesFile = typesFile.replace(pathUtil.extname(typesFile), '')
+        let templateFile =
+            item.importFrom && options.shouldImportCoreSchemas
+                ? `schema/imported.schema.ts.hbs`
+                : undefined
+
+        if (language === 'go') {
+            templateFile = 'schema/schema.go.hbs'
         }
 
         const schemaContents = this.templates.schema({
@@ -227,23 +252,42 @@ export default class SchemaWriter extends AbstractWriter {
             fieldTemplateItems,
             valueTypes,
             typesFile,
-            schemaFile:
-                item.importFrom && options.shouldImportCoreSchemas
-                    ? `schema/imported.schema.ts.hbs`
-                    : undefined,
+            schema,
+            language: language === 'go' ? 'go' : 'typescript',
+            schemaFile: templateFile,
         })
 
         return this.writeFileIfChangedMixinResults(
             resolvedDestination,
             schemaContents,
             `${
-                item.schema.description ? `${item.schema.description} ` : ''
+                schema.description ? `${schema.description} ` : ''
             }This is the schema generated by ${
                 item.id
             }.builder.ts. AUTOGENERATED. DO NOT EDIT.`
         )
     }
 
+    private resolveTypesFile(
+        typesFile: string | undefined,
+        resolvedDestination: string
+    ) {
+        let resolvedType = typesFile
+            ? diskUtil.resolveRelativePath(
+                  pathUtil.dirname(resolvedDestination),
+                  typesFile
+              )
+            : undefined
+
+        if (resolvedType) {
+            resolvedType = resolvedType.replace(
+                pathUtil.extname(resolvedType),
+                ''
+            )
+        }
+        return resolvedType
+    }
+
     public async writeValueTypes(
         destinationDir: string,
         options: {
@@ -297,4 +341,6 @@ export interface GenerateSchemaTypesOptions {
     typesTemplate?: string
     registerBuiltSchemas?: boolean
     shouldImportCoreSchemas: boolean
+    language?: ProjectLanguage
+    goModuleNameAndPath?: string
 }

package/src/features/skill/SkillFeature.ts

@@ -19,7 +19,7 @@ export default class SkillFeature<
     public description = 'The scaffolding needed to run a Skill'
     public readonly installOrderWeight = 100
 
-    public packageDependencies: NpmPackage[] = [
+    protected _packageDependencies: NpmPackage[] = [
         { name: '@sprucelabs/error' },
         { name: '@sprucelabs/spruce-skill-utils' },
         { name: '@sprucelabs/spruce-skill-booter' },

package/src/features/skill/stores/SkillStore.ts

@@ -1,5 +1,6 @@
+import path from 'path'
 import { SpruceSchemas } from '@sprucelabs/spruce-core-schemas'
-import { namesUtil } from '@sprucelabs/spruce-skill-utils'
+import { diskUtil, namesUtil } from '@sprucelabs/spruce-skill-utils'
 import SpruceError from '../../../errors/SpruceError'
 import AbstractStore, { StoreOptions } from '../../../stores/AbstractStore'
 import { CurrentSkill, RegisteredSkill } from '../../../types/cli.types'
@@ -130,25 +131,66 @@ export default class SkillStoreImpl
         return skill.isRegistered
     }
 
+    public getGoModuleName(options?: { shouldIncludePathFromCwd?: boolean }) {
+        const { shouldIncludePathFromCwd = false } = options || {}
+
+        let goModFile = diskUtil.resolvePath(this.cwd, 'go.mod')
+        if (!diskUtil.doesFileExist(goModFile)) {
+            goModFile = diskUtil.resolvePath(this.cwd, '../go.mod')
+        }
+
+        if (!diskUtil.doesFileExist(goModFile)) {
+            throw new SpruceError({
+                code: 'DIRECTORY_NOT_GO_MODULE',
+                friendlyMessage: `Couldn't find a go.mod file in the current directory or its parent. Are you in a Go module?`,
+                cwd: this.cwd,
+            })
+        }
+        const goModContents = diskUtil.readFile(goModFile)
+        const moduleLine = goModContents.match(/module\s+([^\s]+)/)
+        const goModuleName = moduleLine?.[1] as string
+
+        if (shouldIncludePathFromCwd) {
+            const goModDir = path.dirname(goModFile)
+            const relativePath = this.cwd.replace(goModDir, '')
+
+            if (relativePath) {
+                return `${goModuleName}${relativePath}`
+            }
+        }
+
+        return goModuleName
+    }
+
     private getNamespaceFromPkg() {
+        if (this.isGoModule()) {
+            const module = this.getGoModuleName()
+            const moduleParts = module.split('/') ?? []
+            return moduleParts.pop() as string
+        }
+
         const nameFromPackage = this.Service('pkg').getSkillNamespace()
         if (!nameFromPackage) {
             throw new Error(
                 'You need need to set skill.namespace in the package.json'
             )
         }
-        return nameFromPackage
+        return nameFromPackage as string
+    }
+
+    private isGoModule() {
+        return diskUtil.detectProjectLanguage(this.cwd) === 'go'
     }
 
     public async loadCurrentSkillsNamespace() {
-        const fallback = namesUtil.toPascal(this.getNamespaceFromPkg())
+        const fallback = this.getNamespaceFromPkg()
 
-        if (this.Service('auth').getCurrentSkill()) {
+        if (!this.isGoModule() && this.Service('auth').getCurrentSkill()) {
             const current = await this.loadCurrentSkill()
             return namesUtil.toPascal(current.slug ?? fallback)
         }
 
-        return fallback
+        return namesUtil.toPascal(fallback)
     }
 
     public async setCurrentSkillsNamespace(namespace: string) {
@@ -200,6 +242,10 @@ export default class SkillStoreImpl
         return this.fetchAllSkills({ shouldOnlyShowMine: true })
     }
 
+    public static setCurrentSkill(skill: CurrentSkill) {
+        this.currentSkill = skill
+    }
+
     public async fetchAllSkills(query?: {
         shouldOnlyShowMine?: boolean
         namespaces?: string[]

package/src/features/store/StoreFeature.ts

@@ -16,7 +16,7 @@ export default class StoreFeature extends AbstractFeature {
             isRequired: true,
         },
     ]
-    public packageDependencies = [
+    public _packageDependencies = [
         { name: '@sprucelabs/spruce-store-plugin@latest', isDev: false },
         { name: '@sprucelabs/data-stores@latest', isDev: false },
     ]

package/src/features/test/TestFeature.ts

@@ -25,7 +25,7 @@ export default class TestFeature extends AbstractFeature {
         { code: 'skill', isRequired: false },
         { code: 'node', isRequired: true },
     ]
-    public packageDependencies: NpmPackage[] = [
+    public _packageDependencies: NpmPackage[] = [
         { name: '@sprucelabs/test@latest', isDev: true },
         { name: '@sprucelabs/test-utils@latest', isDev: true },
         { name: '@sprucelabs/jest-json-reporter@latest', isDev: true },

package/src/features/test/TestReporter.ts

@@ -54,7 +54,7 @@ export default class TestReporter {
     private minWidth = 50
     private isRpTraining: boolean
     private trainingTokenPopup?: PopupWidget
-    private shouldStripCwdFromErrors = false
+    private shouldStripCwdFromErrors = true
     // private orientationWhenErrorLogWasShown: TestReporterOrientation =
     // 'landscape'
 

package/src/features/view/ViewFeature.ts

@@ -9,7 +9,7 @@ export default class ViewFeature extends AbstractFeature {
     public code: FeatureCode = 'view'
     public actionsDir = diskUtil.resolvePath(__dirname, 'actions')
 
-    public readonly packageDependencies: NpmPackage[] = [
+    public readonly _packageDependencies: NpmPackage[] = [
         {
             name: '@sprucelabs/heartwood-view-controllers@latest',
         },

package/src/packageManager/NodePackageManager.ts

@@ -0,0 +1,115 @@
+import pathUtil from 'path'
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { CommandService } from '../services/CommandService'
+import PkgService, { AddOptions } from '../services/PkgService'
+import isCi from '../utilities/isCi'
+import {
+    PackageManager,
+    PackageManagerConstructorOptions,
+} from './packageManager.types'
+
+export default class NodePackageManager implements PackageManager {
+    private pkgService: PkgService
+    private cwd: string
+    private commandService: CommandService
+
+    public constructor(options: PackageManagerConstructorOptions) {
+        const { pkgService, commandService, cwd } = options
+        this.pkgService = pkgService
+        this.commandService = commandService
+        this.cwd = cwd
+    }
+
+    public async installDependencies(
+        pkg?: string[] | string,
+        options?: AddOptions
+    ) {
+        const shouldCleanupLockFiles = options?.shouldCleanupLockFiles !== false
+        const deleteLockFile = shouldCleanupLockFiles
+            ? () => this.pkgService.deleteLockFile()
+            : () => {}
+
+        if (!pkg) {
+            await this.commandService.execute('yarn', { args: ['install'] })
+            deleteLockFile()
+            return { totalInstalled: -1, totalSkipped: -1 }
+        }
+
+        deleteLockFile()
+
+        const packages = Array.isArray(pkg) ? pkg : [pkg]
+        const toInstall = []
+        const labsModules: string[] = []
+
+        let totalInstalled = 0
+        let totalSkipped = 0
+
+        for (const thisPackage of packages) {
+            const isInstalled =
+                !options?.shouldForceInstall &&
+                this.pkgService.isInstalled(thisPackage)
+            if (thisPackage.startsWith('@sprucelabs/') || !isInstalled) {
+                toInstall.push(this.pkgService.stripLatest(thisPackage))
+                totalInstalled++
+            } else {
+                totalSkipped++
+            }
+        }
+
+        if (totalInstalled > 0) {
+            const { executable, args } = this.buildCommandAndArgs(
+                toInstall,
+                options
+            )
+
+            const isInWorkspace = this.pkgService.get('workspaces')?.length > 0
+            if (isInWorkspace) {
+                args.push('-W')
+            }
+
+            await this.commandService.execute(executable, {
+                args,
+            })
+        } else if (
+            !diskUtil.doesDirExist(pathUtil.join(this.cwd, 'node_modules'))
+        ) {
+            await this.commandService.execute('yarn', { args: ['install'] })
+        }
+
+        deleteLockFile()
+
+        return {
+            totalInstalled: totalInstalled + labsModules.length,
+            totalSkipped,
+        }
+    }
+
+    public async uninstallDependencies(pkg: string[] | string) {
+        const packages = Array.isArray(pkg) ? pkg : [pkg]
+        const args: string[] = ['uninstall', ...packages]
+        await this.commandService.execute('npm', {
+            args,
+        })
+
+        await this.installDependencies()
+    }
+
+    private buildCommandAndArgs(
+        toInstall: string[],
+        options: AddOptions | undefined
+    ) {
+        const args: any[] = [
+            isCi() && '--cache-folder',
+            isCi() && diskUtil.createRandomTempDir(),
+            'add',
+            ...toInstall,
+        ].filter((a) => !!a)
+
+        if (options?.isDev) {
+            args.push('-D')
+        }
+
+        const executable = 'yarn'
+        return { executable, args }
+    }
+}

package/src/packageManager/packageManager.types.ts

@@ -0,0 +1,21 @@
+import { CommandService } from '../services/CommandService'
+import PkgService, { AddOptions } from '../services/PkgService'
+
+export interface PackageManager {
+    installDependencies(
+        pkg?: string[] | string,
+        options?: AddOptions
+    ): Promise<{
+        totalInstalled: number
+        totalSkipped: number
+    }>
+    uninstallDependencies?(dependencies: string[] | string): Promise<void>
+    isInstalled?(pkg: string): boolean
+    deleteLockFile?(): void
+}
+
+export interface PackageManagerConstructorOptions {
+    pkgService: PkgService
+    commandService: CommandService
+    cwd: string
+}