@sprucelabs/spruce-cli 29.1.1 → 29.2.0

package/src/__tests__/behavioral/upgrading/UpgradingAMonorepo.test.ts

@@ -0,0 +1,166 @@
+import { diskUtil } from '@sprucelabs/spruce-skill-utils'
+import { test, assert } from '@sprucelabs/test-utils'
+import CommandServiceImpl from '../../../services/CommandService'
+import PkgService from '../../../services/PkgService'
+import AbstractCliTest from '../../../tests/AbstractCliTest'
+
+export default class UpgradingAMonorepoTest extends AbstractCliTest {
+    private static monorepoDir: string
+    private static packageADir: string
+    private static packageBDir: string
+    private static wackyPackageName: string
+    private static pkg: PkgService
+    private static monoRepoPkg: PkgService
+    private static passedYarnArgs: string[] = []
+    private static yarnHitCount = 0
+
+    protected static async beforeAll() {
+        await super.beforeAll()
+        await this.setupMonorepo()
+    }
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.passedYarnArgs = []
+        this.yarnHitCount = 0
+
+        this.cwd = this.monorepoDir
+        this.monoRepoPkg = this.Service('pkg', this.monorepoDir)
+    }
+
+    @test()
+    protected static async canUpgradePackageAInMonorepo() {
+        this.setCwd(this.packageADir)
+        this.fakeYarnCommands()
+        await this.assertUpgradePasses()
+    }
+
+    @test()
+    protected static async canUpgradePackageBWithCrossDependency() {
+        this.setCwd(this.packageBDir)
+
+        this.fakeYarnCommands()
+
+        await this.assertUpgradePasses()
+
+        assert.isEqual(
+            this.yarnHitCount,
+            3,
+            'Should not try and install if only module is ignored'
+        )
+
+        this.assertDidNotUpgradePackageA()
+    }
+
+    @test()
+    protected static async canUpgradeWithRandomlyNamedSiblingPackage() {
+        this.wackyPackageName = `package-${Math.random()}`
+        this.createMinimalPackage(this.wackyPackageName)
+
+        this.addDependency(this.packageADir, this.wackyPackageName, '^1.0.0')
+        this.addDependency(this.packageBDir, this.wackyPackageName, '^1.0.0')
+
+        this.setCwd(this.packageADir)
+        this.fakeYarnCommands()
+
+        await this.assertUpgradePasses()
+
+        this.assertPackageSkipped(this.wackyPackageName)
+    }
+
+    private static assertDidNotUpgradePackageA() {
+        this.assertPackageSkipped('package-a')
+    }
+
+    private static assertPackageSkipped(packageName: string) {
+        assert.doesNotInclude(
+            this.passedYarnArgs,
+            packageName,
+            `Should not try to upgrade ${packageName}`
+        )
+    }
+
+    private static fakeYarnCommands() {
+        CommandServiceImpl.fakeCommand(/yarn*/, {
+            code: 0,
+            callback: (_, args) => {
+                this.passedYarnArgs.push(...args)
+                this.yarnHitCount++
+            },
+        })
+    }
+
+    private static async assertUpgradePasses() {
+        const results = await this.Action('node', 'upgrade').execute({})
+        assert.isFalsy(results.errors, 'Should not have errors')
+    }
+
+    private static async setupMonorepo() {
+        this.monorepoDir = this.freshTmpDir()
+        this.setCwd(this.monorepoDir)
+
+        this.createRootPackageJson()
+
+        this.packageADir = await this.createModule('package-a')
+        this.packageBDir = await this.createModule('package-b')
+
+        this.addDependency(this.packageBDir, 'package-a', '^1.0.0')
+    }
+
+    private static createRootPackageJson() {
+        this.setCwd(this.monorepoDir)
+        const pkgPath = this.resolvePath('package.json')
+        diskUtil.writeFile(pkgPath, '{}')
+
+        this.monoRepoPkg = this.Service('pkg')
+        this.monoRepoPkg.set({ path: ['name'], value: 'test-monorepo' })
+        //@ts-ignore REMOVE WHEN YOU FIND THIS, TYPES UPDATED
+        this.monoRepoPkg.set({ path: ['private'], value: true })
+        this.monoRepoPkg.set({ path: ['workspaces'], value: ['packages/*'] })
+    }
+
+    private static async createModule(name: string) {
+        const packageDir = this.resolvePackageDir(name)
+        diskUtil.createDir(packageDir)
+        this.setCwd(packageDir)
+
+        await this.Action('node', 'create', {
+            shouldAutoHandleDependencies: true,
+        }).execute({
+            name,
+            description: `Test module ${name}`,
+        })
+
+        return packageDir
+    }
+
+    private static resolvePackageDir(name: string) {
+        return diskUtil.resolvePath(this.monorepoDir, 'packages', name)
+    }
+
+    private static addDependency(
+        packageDir: string,
+        depName: string,
+        version: string
+    ) {
+        this.pkg = this.Service('pkg', packageDir)
+        this.pkg.set({
+            path: ['dependencies', depName],
+            value: version,
+        })
+    }
+
+    private static createMinimalPackage(name: string) {
+        const packageDir = this.resolvePackageDir(name)
+        diskUtil.createDir(packageDir)
+
+        const pkgPath = diskUtil.resolvePath(packageDir, 'package.json')
+        diskUtil.writeFile(
+            pkgPath,
+            JSON.stringify({ name, version: '1.0.0' }, null, 2)
+        )
+
+        return packageDir
+    }
+}

package/src/components/QuizComponent.ts

@@ -34,8 +34,10 @@ enum AnswerValidity {
     Incorrect = 'incorrect',
 }
 
-interface QuizPresentationOptions<T extends Schema, Q extends QuizQuestions>
-    extends Omit<FormPresentationOptions<T>, 'fields'> {
+interface QuizPresentationOptions<
+    T extends Schema,
+    Q extends QuizQuestions,
+> extends Omit<FormPresentationOptions<T>, 'fields'> {
     questions?: QuizAnswerFieldNames<Q>[]
     randomizeQuestions?: boolean
 }
@@ -77,8 +79,10 @@ interface QuizPresentationResults<Q extends QuizQuestions> {
     totalQuestions: number
 }
 
-interface QuizOptions<T extends Schema, Q extends QuizQuestions>
-    extends Omit<FormOptions<T>, 'schema'> {
+interface QuizOptions<T extends Schema, Q extends QuizQuestions> extends Omit<
+    FormOptions<T>,
+    'schema'
+> {
     /** Should we randomize the questions */
     randomizeQuestions?: boolean
     /** The questions we are asking */

package/src/features/AbstractFeature.ts

@@ -31,8 +31,7 @@ import { FeatureCode } from './features.types'
 
 export default abstract class AbstractFeature<
     S extends Schema | undefined = Schema | undefined,
-> implements ServiceProvider
-{
+> implements ServiceProvider {
     public abstract description: string
     public readonly dependencies: FeatureDependency[] = []
     protected _packageDependencies: PackageDependency[] = []

package/src/features/ActionFactory.ts

@@ -121,11 +121,10 @@ export default class ActionFactory {
     }
 }
 
-export interface FeatureActionFactoryOptions
-    extends Omit<
-        ActionOptions,
-        'parent' | 'actionExecuter' | 'featureInstaller'
-    > {
+export interface FeatureActionFactoryOptions extends Omit<
+    ActionOptions,
+    'parent' | 'actionExecuter' | 'featureInstaller'
+> {
     emitter: GlobalEmitter
     blockedCommands?: BlockedCommands
     optionOverrides?: OptionOverrides

package/src/features/ActionQuestionAsker.ts

@@ -17,8 +17,7 @@ import {
 
 export default class ActionQuestionAskerImpl<
     F extends FeatureCode = FeatureCode,
-> implements ActionQuestionAsker<F>
-{
+> implements ActionQuestionAsker<F> {
     private ui: GraphicsInterface
     public static Class?: new (
         options: ActionQuestionAskerOptions

package/src/features/onboard/stores/OnboardingStore.ts

@@ -8,7 +8,8 @@ import AbstractLocalStore, {
 import { StoreOptions } from '../../../stores/AbstractStore'
 
 export interface OnboardingStoreSettings
-    extends LocalStoreSettings,
+    extends
+        LocalStoreSettings,
         SpruceSchemas.SpruceCli.v2020_07_22.Onboarding {}
 
 type OnboardingSchema = SpruceSchemas.SpruceCli.v2020_07_22.OnboardingSchema

package/src/features/test/TestReporter.ts

@@ -53,10 +53,7 @@ export default class TestReporter {
     private handleToggleSmartWatch?: () => any
     private minWidth = 50
     private isRpTraining: boolean
-    private trainingTokenPopup?: PopupWidget
     private shouldStripCwdFromErrors = true
-    // private orientationWhenErrorLogWasShown: TestReporterOrientation =
-    // 'landscape'
 
     public constructor(options?: TestReporterOptions) {
         this.cwd = options?.cwd
@@ -92,10 +89,20 @@ export default class TestReporter {
     }
 
     public setIsRpTraining(isRpTraining: boolean) {
-        this.setLabelStatus('rp', 'Train AI', isRpTraining)
+        this.setRpTrainingStatus(isRpTraining ? 'on' : 'off')
         this.isRpTraining = isRpTraining
     }
 
+    public setRpTrainingStatus(status: 'off' | 'installing' | 'on') {
+        const colors: Record<string, { fg: string; bg: string }> = {
+            off: { fg: 'w', bg: 'r' },
+            installing: { fg: 'k', bg: 'y' },
+            on: { fg: 'k', bg: 'g' },
+        }
+        const { fg, bg } = colors[status]
+        this.menu.setTextForItem('rp', `Train AI ^${fg}^#^${bg} • ^`)
+    }
+
     public startCountdownTimer(durationSec: number) {
         clearInterval(this.countDownTimeInterval)
         this.countDownTimeInterval = undefined
@@ -370,38 +377,93 @@ export default class TestReporter {
         }
     }
 
-    public async askForTrainingToken() {
-        if (this.trainingTokenPopup) {
-            return
-        }
+    public async askForProjectName(
+        defaultName: string
+    ): Promise<string | undefined> {
+        return new Promise((resolve) => {
+            const popup = this.widgets.Widget('popup', {
+                parent: this.window,
+                top: 5,
+                left: 8,
+                width: 65,
+                height: 15,
+            })
 
-        this.trainingTokenPopup = this.widgets.Widget('popup', {
-            parent: this.window,
-            top: 10,
-            left: 10,
-            width: 50,
-            height: 10,
-        })
+            this.widgets.Widget('text', {
+                parent: popup,
+                left: 2,
+                top: 1,
+                height: 1,
+                width: popup.getFrame().width - 4,
+                text: 'regressionproof.ai',
+            })
 
-        this.widgets.Widget('text', {
-            parent: this.trainingTokenPopup,
-            left: 4,
-            top: 3,
-            height: 4,
-            width: this.trainingTokenPopup.getFrame().width - 2,
-            text: 'Coming soon...',
-        })
+            this.widgets.Widget('text', {
+                parent: popup,
+                left: 2,
+                top: 3,
+                height: 4,
+                width: popup.getFrame().width - 4,
+                text: "Help Spruce train coding agents on how to do proper TDD.\nIf you contribute to this effort, you'll get a lifetime\nlicense to the agents for free.",
+            })
 
-        const button = this.widgets.Widget('button', {
-            parent: this.trainingTokenPopup,
-            left: 20,
-            top: 7,
-            text: ' Ok ',
-        })
+            const input = this.widgets.Widget('input', {
+                parent: popup,
+                left: 2,
+                top: 8,
+                label: 'Name',
+                width: popup.getFrame().width - 6,
+                height: 1,
+                value: defaultName,
+            })
 
-        await button.on('click', async () => {
-            await this.trainingTokenPopup?.destroy()
-            delete this.trainingTokenPopup
+            const learnMoreButton = this.widgets.Widget('button', {
+                parent: popup,
+                left: 2,
+                top: 11,
+                text: ' Learn more ',
+            })
+
+            const cancelButton = this.widgets.Widget('button', {
+                parent: popup,
+                left: 40,
+                top: 11,
+                text: ' Cancel ',
+            })
+
+            const enableButton = this.widgets.Widget('button', {
+                parent: popup,
+                left: 50,
+                top: 11,
+                text: ' Enable ',
+            })
+
+            void learnMoreButton.on('click', async () => {
+                const open = await import('open')
+                void open.default('https://regressionproof.ai')
+            })
+
+            void enableButton.on('click', () => {
+                const value = input.getValue()
+                void popup.destroy()
+                resolve(value || undefined)
+            })
+
+            void cancelButton.on('click', () => {
+                void popup.destroy()
+                resolve(undefined)
+            })
+
+            void input.on('submit', () => {
+                const value = input.getValue()
+                void popup.destroy()
+                resolve(value || undefined)
+            })
+
+            void input.on('cancel', () => {
+                void popup.destroy()
+                resolve(undefined)
+            })
         })
     }
 
@@ -638,7 +700,6 @@ export default class TestReporter {
         this.testLog.setText(logContent)
 
         if (!errorContent) {
-            // this.errorLog && this.destroyErrorLog()
             this.errorLog?.setText('  Nothing to report...')
         } else {
             !this.errorLog && this.dropInErrorLog()
@@ -678,8 +739,6 @@ export default class TestReporter {
     }
 
     private dropInErrorLog() {
-        // this.orientationWhenErrorLogWasShown = this.orientation
-
         if (this.bottomLayout.getRows().length === 1) {
             if (this.orientation === 'portrait') {
                 this.bottomLayout.addRow({
@@ -719,24 +778,7 @@ export default class TestReporter {
         }
     }
 
-    private destroyErrorLog() {
-        // if (this.errorLog) {
-        //     void this.errorLog?.destroy()
-        //     this.errorLog = undefined
-        //     if (this.orientationWhenErrorLogWasShown === 'landscape') {
-        //         this.bottomLayout.removeColumn(0, 1)
-        //         this.bottomLayout.setColumnWidth({
-        //             rowIdx: 0,
-        //             columnIdx: 0,
-        //             width: '100%',
-        //         })
-        //     } else {
-        //         this.bottomLayout.removeRow(1)
-        //         this.bottomLayout.setRowHeight(0, '100%')
-        //     }
-        //     this.bottomLayout.updateLayout()
-        // }
-    }
+    private destroyErrorLog() {}
 
     private updateProgressBar(results: SpruceTestResults) {
         if (results.totalTestFilesComplete ?? 0 > 0) {

package/src/features/test/TestRunner.ts

@@ -29,6 +29,7 @@ export default class TestRunner extends AbstractEventEmitter<TestRunnerContract>
     public async run(options?: {
         pattern?: string | null
         debugPort?: number | null
+        isRpTraining?: boolean
     }): Promise<SpruceTestResults & { wasKilled: boolean }> {
         this.wasKilled = false
 
@@ -45,7 +46,10 @@ export default class TestRunner extends AbstractEventEmitter<TestRunnerContract>
                 '"'
             )
         }
-        const command = `node --experimental-vm-modules --unhandled-rejections=strict ${debugArgs} ${jestPath} --reporters="@sprucelabs/jest-json-reporter" --testRunner="jest-circus/runner" --passWithNoTests ${
+        const rpReporter = options?.isRpTraining
+            ? ' --reporters="@regressionproof/jest-reporter"'
+            : ''
+        const command = `node --experimental-vm-modules --unhandled-rejections=strict ${debugArgs} ${jestPath} --reporters="@sprucelabs/jest-json-reporter"${rpReporter} --testRunner="jest-circus/runner" --passWithNoTests ${
             pattern ? escapeShell(pattern) : ''
         }`
 

package/src/features/test/actions/TestAction.ts

@@ -50,11 +50,17 @@ export default class TestAction extends AbstractAction<OptionsSchema> {
     public async execute(
         options: SchemaValues<OptionsSchema>
     ): Promise<FeatureActionResponse> {
+        const settings = this.Service('settings')
+
         if (!options.watchMode) {
-            const settings = this.Service('settings')
             options.watchMode = settings.get('test.watchMode') ?? 'off'
         }
 
+        const rpSettings = settings.get('regressionproof') as
+            | { enabled: boolean; projectName: string }
+            | undefined
+        this.isRpTraining = rpSettings?.enabled ?? false
+
         const normalizedOptions = this.validateAndNormalizeOptions(options)
 
         const {
@@ -247,11 +253,84 @@ export default class TestAction extends AbstractAction<OptionsSchema> {
     }
 
     private async handleToggleRpTraining() {
-        // this.isRpTraining = !this.isRpTraining
-        // this.testReporter?.setIsRpTraining(this.isRpTraining)
-        // if (this.isRpTraining) {
-        await this.testReporter?.askForTrainingToken()
-        // }
+        const settings = this.Service('settings')
+        const rpSettings = settings.get('regressionproof') as
+            | { enabled: boolean; projectName: string }
+            | undefined
+
+        if (!rpSettings) {
+            const defaultName = await this.getDefaultProjectName()
+            const projectName =
+                await this.testReporter?.askForProjectName(defaultName)
+
+            if (projectName) {
+                try {
+                    this.testReporter?.setRpTrainingStatus('installing')
+                    this.testReporter?.setStatusLabel(
+                        'Installing regressionproof packages...'
+                    )
+
+                    const pkgService = this.Service('pkg')
+                    await pkgService.install(
+                        [
+                            '@regressionproof/cli',
+                            '@regressionproof/jest-reporter',
+                        ],
+                        { isDev: true }
+                    )
+
+                    this.testReporter?.setStatusLabel(
+                        'Initializing regressionproof...'
+                    )
+
+                    const commandService = this.Service('command')
+                    await commandService.execute(
+                        `node node_modules/@regressionproof/cli/build/cli.js init ${projectName}`,
+                        { ignoreErrors: true }
+                    )
+
+                    settings.set('regressionproof', {
+                        enabled: true,
+                        projectName,
+                    })
+                    this.isRpTraining = true
+                    this.testReporter?.setIsRpTraining(true)
+                    this.testReporter?.setStatusLabel('')
+                } catch (err: any) {
+                    this.testReporter?.setRpTrainingStatus('off')
+                    const message = err?.message ?? 'Unknown error'
+                    this.testReporter?.setStatusLabel(
+                        `Setup failed: ${message}`
+                    )
+                }
+            }
+        } else {
+            const newEnabled = !rpSettings.enabled
+            settings.set('regressionproof', {
+                ...rpSettings,
+                enabled: newEnabled,
+            })
+            this.isRpTraining = newEnabled
+            this.testReporter?.setIsRpTraining(newEnabled)
+        }
+    }
+
+    private async getDefaultProjectName(): Promise<string> {
+        try {
+            const commandService = this.Service('command')
+            const result = await commandService.execute(
+                'git remote get-url origin',
+                { ignoreErrors: true }
+            )
+            if (result.stdout) {
+                const match = result.stdout.match(/\/([^/]+?)(?:\.git)?$/)
+                if (match) {
+                    return match[1].replace('.git', '')
+                }
+            }
+        } catch {}
+
+        return pathUtil.basename(this.cwd)
     }
 
     public setWatchMode(mode: WatchMode) {
@@ -381,6 +460,7 @@ export default class TestAction extends AbstractAction<OptionsSchema> {
         let testResults: SpruceTestResults = await this.testRunner.run({
             pattern: this.pattern,
             debugPort: this.inspect,
+            isRpTraining: this.isRpTraining,
         })
 
         if (

package/src/services/PkgService.ts

@@ -1,3 +1,5 @@
+import fsUtil from 'fs'
+import pathUtil from 'path'
 import {
     diskUtil,
     PkgService as BasePkgService,
@@ -25,7 +27,51 @@ export default class PkgService extends BasePkgService {
     }
 
     public async install(pkg?: string[] | string, options?: AddOptions) {
-        return this.packageManager.installDependencies(pkg, options)
+        const filtered = this.filterOutWorkspaceSiblings(pkg)
+        if (Array.isArray(filtered) && filtered.length === 0) {
+            return { totalInstalled: 0 }
+        }
+        return this.packageManager.installDependencies(filtered, options)
+    }
+
+    private filterOutWorkspaceSiblings(
+        pkg?: string[] | string
+    ): string[] | string | undefined {
+        if (!pkg) {
+            return pkg
+        }
+        const siblings = this.getWorkspaceSiblingNames()
+        const packages = Array.isArray(pkg) ? pkg : [pkg]
+        const filtered = packages.filter((p) => !siblings.includes(p))
+        return Array.isArray(pkg) ? filtered : filtered[0]
+    }
+
+    private getWorkspaceSiblingNames(): string[] {
+        const packagesDir = pathUtil.dirname(this.cwd)
+        if (pathUtil.basename(packagesDir) !== 'packages') {
+            return []
+        }
+
+        const monorepoRoot = pathUtil.dirname(packagesDir)
+        const rootPkgPath = pathUtil.join(monorepoRoot, 'package.json')
+        if (!diskUtil.doesFileExist(rootPkgPath)) {
+            return []
+        }
+
+        const siblingDirs = fsUtil.readdirSync(packagesDir)
+        const names: string[] = []
+
+        for (const dir of siblingDirs) {
+            const pkgPath = pathUtil.join(packagesDir, dir, 'package.json')
+            if (diskUtil.doesFileExist(pkgPath)) {
+                const siblingPkg = JSON.parse(diskUtil.readFile(pkgPath))
+                if (siblingPkg.name) {
+                    names.push(siblingPkg.name)
+                }
+            }
+        }
+
+        return names
     }
 
     public getSkillNamespace() {

package/src/tests/AbstractCliTest.ts

@@ -138,6 +138,7 @@ export default abstract class AbstractCliTest extends AbstractSpruceTest {
         }
 
         if (
+            this.homeDir &&
             diskUtil.doesDirExist(this.homeDir) &&
             testUtil.shouldClearCache()
         ) {

package/src/tests/staticToInstanceMigration/StaticToInstanceMigrator.ts

@@ -4,9 +4,7 @@ import LintService from '../../services/LintService'
 import StaticTestFinder from './StaticTestFinder'
 import { StaticToInstanceTestFileMigrator } from './StaticToInstanceTestFileMigrator'
 
-export default class StaticToInstanceMigratorImpl
-    implements StaticToInstanceMigrator
-{
+export default class StaticToInstanceMigratorImpl implements StaticToInstanceMigrator {
     public static diskUtil = diskUtil
     public static Class?: new (
         options: StaticToInstanceMigratorOptions

package/src/tests/staticToInstanceMigration/StaticToInstanceTestFileMigrator.ts

@@ -1,8 +1,6 @@
 import { assertOptions } from '@sprucelabs/schema'
 
-export default class StaticToInstanceTestFileMigratorImpl
-    implements StaticToInstanceTestFileMigrator
-{
+export default class StaticToInstanceTestFileMigratorImpl implements StaticToInstanceTestFileMigrator {
     public static Class?: new () => StaticToInstanceTestFileMigrator
 
     public static Migrator() {