@sprucelabs/spruce-cli 29.1.2 → 29.2.1

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,142 @@ export default class TestReporter {
         }
     }
 
-    public async askForTrainingToken() {
-        if (this.trainingTokenPopup) {
-            return
-        }
+    public async showAlert(options: { title: string; message: string }) {
+        const { title, message } = options
 
-        this.trainingTokenPopup = this.widgets.Widget('popup', {
-            parent: this.window,
-            top: 10,
-            left: 10,
-            width: 50,
-            height: 10,
-        })
+        const windowFrame = this.window.getFrame()
+        const popupHeight = Math.min(windowFrame.height - 4, 25)
 
-        this.widgets.Widget('text', {
-            parent: this.trainingTokenPopup,
-            left: 4,
-            top: 3,
-            height: 4,
-            width: this.trainingTokenPopup.getFrame().width - 2,
-            text: 'Coming soon...',
-        })
+        return new Promise<void>((resolve) => {
+            const popup = this.widgets.Widget('popup', {
+                parent: this.window,
+                top: 2,
+                left: 4,
+                width: Math.min(windowFrame.width - 8, 80),
+                height: popupHeight,
+            })
 
-        const button = this.widgets.Widget('button', {
-            parent: this.trainingTokenPopup,
-            left: 20,
-            top: 7,
-            text: ' Ok ',
+            this.widgets.Widget('text', {
+                parent: popup,
+                left: 2,
+                top: 1,
+                height: 1,
+                width: popup.getFrame().width - 4,
+                text: title,
+            })
+
+            this.widgets.Widget('text', {
+                parent: popup,
+                left: 2,
+                top: 3,
+                height: popupHeight - 7,
+                width: popup.getFrame().width - 4,
+                text: message,
+                isScrollEnabled: true,
+                wordWrap: true,
+            })
+
+            const okButton = this.widgets.Widget('button', {
+                parent: popup,
+                left: Math.floor(popup.getFrame().width / 2) - 4,
+                top: popupHeight - 3,
+                text: '   OK   ',
+            })
+
+            void okButton.on('click', () => {
+                void popup.destroy()
+                resolve()
+            })
         })
+    }
+
+    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.widgets.Widget('text', {
+                parent: popup,
+                left: 2,
+                top: 1,
+                height: 1,
+                width: popup.getFrame().width - 4,
+                text: 'regressionproof.ai',
+            })
+
+            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 input = this.widgets.Widget('input', {
+                parent: popup,
+                left: 2,
+                top: 8,
+                label: 'Name',
+                width: popup.getFrame().width - 6,
+                height: 1,
+                value: defaultName,
+            })
+
+            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)
+            })
 
-        await button.on('click', async () => {
-            await this.trainingTokenPopup?.destroy()
-            delete this.trainingTokenPopup
+            void input.on('cancel', () => {
+                void popup.destroy()
+                resolve(undefined)
+            })
         })
     }
 
@@ -638,7 +749,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 +788,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 +827,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,86 @@ 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: projectName.trim(),
+                    })
+                    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('')
+                    await this.testReporter?.showAlert({
+                        title: 'Train AI Setup Failed',
+                        message: `Could not set up regressionproof:\n\n${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 +462,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()
         ) {