t44 0.2.0-rc.1

package/caps/WorkspacePrompt.v0.ts

@@ -0,0 +1,396 @@
+
+// Global prompt queue to ensure sequential prompting and deduplication
+const globalPromptQueue: Array<() => Promise<any>> = []
+const globalActivePrompts: Record<string, Promise<any>> = {}
+const globalShownTitles: Set<string> = new Set()
+let globalIsProcessing = false
+
+async function processGlobalQueue() {
+    if (globalIsProcessing || globalPromptQueue.length === 0) return
+    globalIsProcessing = true
+
+    while (globalPromptQueue.length > 0) {
+        const task = globalPromptQueue.shift()!
+        await task()
+    }
+
+    globalIsProcessing = false
+}
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule.v0': {},
+            '#': {
+                WorkspaceCli: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceCli.v0'
+                },
+                WorkspaceTest: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceTest.v0'
+                },
+                prompt: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, questions: any[]): Promise<any> {
+                        // Check if --yes flag is set
+                        const cliOptions = await this.WorkspaceCli.cliOptions
+                        const yes = cliOptions?.yes || false
+
+                        // If --yes is set, return default values
+                        if (yes) {
+                            const result: Record<string, any> = {}
+                            for (const question of questions) {
+                                result[question.name] = question.default
+                            }
+                            return result
+                        }
+
+                        // Otherwise, load inquirer and prompt user
+                        const inquirer = await import('inquirer')
+                        try {
+                            return await inquirer.default.prompt(questions)
+                        } catch (error: any) {
+                            if (error.message?.includes('SIGINT') || error.message?.includes('force closed')) {
+                                const chalk = (await import('chalk')).default
+                                console.log(chalk.red('\n\nABORTED\n'))
+                                process.exit(0)
+                            }
+                            throw error
+                        }
+                    }
+                },
+                confirm: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, {
+                        title,
+                        description,
+                        message,
+                        defaultValue = false,
+                        onSuccess,
+                        onAbort
+                    }: {
+                        title?: string
+                        description?: string | string[]
+                        message: string
+                        defaultValue?: boolean
+                        onSuccess?: (confirmed: boolean) => Promise<void> | void
+                        onAbort?: () => Promise<void> | void
+                    }): Promise<boolean> {
+                        const chalk = (await import('chalk')).default
+
+                        if (title) {
+                            console.log(chalk.cyan(`\n${title}\n`))
+                        }
+                        if (description) {
+                            const lines = Array.isArray(description) ? description : [description]
+                            for (const line of lines) {
+                                console.log(chalk.gray(`   ${line}`))
+                            }
+                            console.log('')
+                        }
+
+                        // Check if --yes flag is set
+                        const cliOptions = await this.WorkspaceCli.cliOptions
+                        const yes = cliOptions?.yes || false
+
+                        let confirmed: boolean
+
+                        // If --yes is set, return default value
+                        if (yes) {
+                            confirmed = defaultValue
+                        } else {
+                            try {
+                                // Otherwise, load inquirer and prompt user
+                                const inquirer = await import('inquirer')
+                                const result = await inquirer.default.prompt([
+                                    {
+                                        type: 'confirm',
+                                        name: 'confirmed',
+                                        message,
+                                        default: defaultValue
+                                    }
+                                ])
+                                confirmed = result.confirmed
+                            } catch (error: any) {
+                                if (error.message?.includes('SIGINT') || error.message?.includes('force closed')) {
+                                    console.log(chalk.red('\n\nABORTED\n'))
+                                    if (onAbort) {
+                                        await onAbort()
+                                    }
+                                    process.exit(0)
+                                }
+                                throw error
+                            }
+                        }
+
+                        if (onSuccess) {
+                            await onSuccess(confirmed)
+                        }
+
+                        return confirmed
+                    }
+                },
+                input: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, {
+                        message,
+                        defaultValue,
+                        validate,
+                        promptFactId
+                    }: {
+                        message: string
+                        defaultValue?: string
+                        validate?: (input: string) => boolean | string
+                        promptFactId?: string
+                    }): Promise<string> {
+                        // Try to get value from env first (works in both interactive and non-interactive modes)
+                        if (promptFactId) {
+                            const envValue = this.getEnvValueForFactReference(promptFactId)
+                            if (envValue) {
+                                return envValue
+                            }
+                        }
+
+                        // In non-interactive mode, throw error if env value not found
+                        if (!process.stdin.isTTY && promptFactId) {
+                            throw new Error(
+                                `Cannot prompt for "${message}" in non-interactive mode. ` +
+                                `Please run interactively first to configure credentials, or set the corresponding env variable.`
+                            )
+                        }
+
+                        // Check for existing prompt with same ID
+                        if (promptFactId && promptFactId in globalActivePrompts) {
+                            return globalActivePrompts[promptFactId]
+                        }
+
+                        // Create the prompt task
+                        const promptTask = async () => {
+                            try {
+                                // Check if --yes flag is set
+                                const cliOptions = await this.WorkspaceCli.cliOptions
+                                const yes = cliOptions?.yes || false
+
+                                // If --yes is set, return default value
+                                if (yes) {
+                                    if (!defaultValue) {
+                                        throw new Error(`Cannot use --yes flag without a default value for prompt: ${message}`)
+                                    }
+                                    return defaultValue
+                                }
+
+                                // Otherwise, load inquirer and prompt user
+                                const inquirer = await import('inquirer')
+                                const question: any = {
+                                    type: 'input',
+                                    name: 'value',
+                                    message,
+                                    validate
+                                }
+
+                                // Only add default if explicitly provided
+                                if (defaultValue !== undefined) {
+                                    question.default = defaultValue
+                                }
+
+                                const { value } = await inquirer.default.prompt([question])
+                                return value
+                            } catch (error: any) {
+                                if (error.message?.includes('SIGINT') || error.message?.includes('force closed')) {
+                                    const chalk = (await import('chalk')).default
+                                    console.log(chalk.red('\n\nABORTED\n'))
+                                    process.exit(0)
+                                }
+                                throw error
+                            } finally {
+                                // Remove from active prompts when done
+                                if (promptFactId) {
+                                    delete globalActivePrompts[promptFactId]
+                                }
+                            }
+                        }
+
+                        // Create promise and add to queue
+                        const promise = new Promise<string>((resolve, reject) => {
+                            globalPromptQueue.push(async () => {
+                                try {
+                                    const result = await promptTask()
+                                    resolve(result)
+                                } catch (error) {
+                                    reject(error)
+                                }
+                            })
+                        })
+
+                        // Track active prompt
+                        if (promptFactId) {
+                            globalActivePrompts[promptFactId] = promise
+                        }
+
+                        // Start processing queue (inlined to avoid ambient reference issues)
+                        if (!globalIsProcessing && globalPromptQueue.length > 0) {
+                            globalIsProcessing = true
+
+                                // Process queue asynchronously
+                                ; (async () => {
+                                    while (globalPromptQueue.length > 0) {
+                                        const task = globalPromptQueue.shift()!
+                                        await task()
+                                    }
+                                    globalIsProcessing = false
+                                })()
+                        }
+
+                        return promise
+                    }
+                },
+                getEnvValueForFactReference: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, factReference: string): string | undefined {
+                        const workspaceTest = this.WorkspaceTest
+                        if (!workspaceTest) return undefined
+
+                        const envConfig = workspaceTest.env || {}
+
+                        for (const [envVarName, envDef] of Object.entries(envConfig)) {
+                            if ((envDef as any)?.factReference === factReference) {
+                                return workspaceTest.getEnvValue(envVarName)
+                            }
+                        }
+                        return undefined
+                    }
+                },
+                select: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, {
+                        message,
+                        choices,
+                        defaultValue,
+                        pageSize
+                    }: {
+                        message: string
+                        choices: Array<{ name: string; value: any; disabled?: boolean | string }>
+                        defaultValue?: any
+                        pageSize?: number
+                    }): Promise<any> {
+                        // Check if --yes flag is set
+                        const cliOptions = await this.WorkspaceCli.cliOptions
+                        const yes = cliOptions?.yes || false
+
+                        // If --yes is set, return default value
+                        if (yes) {
+                            if (defaultValue === undefined) {
+                                throw new Error(`Cannot use --yes flag without a default value for select: ${message}`)
+                            }
+                            return defaultValue
+                        }
+
+                        // Otherwise, load inquirer and prompt user
+                        const inquirer = await import('inquirer')
+                        try {
+                            const { value } = await inquirer.default.prompt([
+                                {
+                                    type: 'list',
+                                    name: 'value',
+                                    message,
+                                    choices,
+                                    default: defaultValue,
+                                    pageSize: pageSize || 10
+                                }
+                            ])
+                            return value
+                        } catch (error: any) {
+                            if (error.message?.includes('SIGINT') || error.message?.includes('force closed')) {
+                                const chalk = (await import('chalk')).default
+                                console.log(chalk.red('\n\nABORTED\n'))
+                                process.exit(0)
+                            }
+                            throw error
+                        }
+                    }
+                },
+                setupPrompt: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, {
+                        title,
+                        description,
+                        message,
+                        defaultValue,
+                        validate,
+                        configPath,
+                        configKey,
+                        onSuccess,
+                        onAbort
+                    }: {
+                        title: string
+                        description?: string | string[]
+                        message: string
+                        defaultValue: string
+                        validate?: (input: string) => boolean | string
+                        configPath: string[]
+                        configKey?: string
+                        onSuccess?: (value: string) => Promise<void> | void
+                        onAbort?: () => Promise<void> | void
+                    }): Promise<string> {
+                        const chalk = (await import('chalk')).default
+
+                        console.log(chalk.cyan(`\n${title}\n`))
+                        if (description) {
+                            const lines = Array.isArray(description) ? description : [description]
+                            for (const line of lines) {
+                                console.log(chalk.gray(`   ${line}`))
+                            }
+                            console.log('')
+                        }
+
+                        try {
+                            const value = await this.input({
+                                message,
+                                defaultValue,
+                                validate
+                            })
+
+                            if (onSuccess) {
+                                await onSuccess(value)
+                            }
+
+                            const displayKey = configKey || configPath.join('.')
+                            console.log(chalk.green(`\n   ✓ Updated config with ${displayKey}: ${value}\n`))
+
+                            return value
+                        } catch (error: any) {
+                            if (error.message?.includes('SIGINT') || error.message?.includes('force closed')) {
+                                console.log(chalk.red('\n\nABORTED\n'))
+                                if (onAbort) {
+                                    await onAbort()
+                                }
+                                process.exit(0)
+                            }
+                            throw error
+                        }
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+        ambientReferences: {
+            globalPromptQueue,
+            globalActivePrompts,
+            globalShownTitles,
+            globalIsProcessing
+        }
+    })
+}
+capsule['#'] = 't44/caps/WorkspacePrompt.v0'

package/caps/WorkspaceShell.sh

@@ -0,0 +1,39 @@
+#!/bin/sh
+
+set -e
+
+function w_log {
+    if [[ "$1" == "var" ]]; then
+        echo "\033[1;37m[$F_WORKSPACE_BASENAME] $2\033[0m"
+    elif [[ "$1" == "info" ]]; then
+        echo "\033[0;36m[$F_WORKSPACE_BASENAME] $2\033[0m"
+    elif [[ "$1" == "start" ]]; then
+        echo "\033[0;36m[$F_WORKSPACE_BASENAME] $2 ...\033[0m"
+    elif [[ "$1" == "notice" ]]; then
+        echo "\n\033[0;36m[$F_WORKSPACE_BASENAME] NOTICE: $2 ...\033[0m\n"
+    elif [[ "$1" == "success" ]]; then
+        echo "\033[0;32m[$F_WORKSPACE_BASENAME] $2\033[0m"
+    elif [[ "$1" == "error" ]]; then
+        echo "\033[0;31m[$F_WORKSPACE_BASENAME] $2\033[0m" >&2
+    fi
+}
+
+function initWorkspace {
+
+    #${COMMANDS}
+
+}
+
+
+if [ -z "$F_WORKSPACE_DIR" ]; then
+    w_log "error" "ERROR: 'F_WORKSPACE_DIR' env var not set!"
+else
+
+    if [ -z "$F_WORKSPACE_BASENAME" ]; then
+        export F_WORKSPACE_BASENAME="$(basename "${F_WORKSPACE_DIR}")"
+    fi
+
+    initWorkspace ${@:1}
+fi
+
+set +e

package/caps/WorkspaceShell.v0.ts

@@ -0,0 +1,104 @@
+
+import { join, resolve, relative } from 'path'
+import { readFile } from 'fs/promises'
+import { $ } from 'bun'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule.v0': {},
+            '#t44/structs/WorkspaceCliConfig.v0': {
+                as: '$WorkspaceCliConfig'
+            },
+            '#t44/structs/WorkspaceShellConfig.v0': {
+                as: '$ShellConfig'
+            },
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceConfig.v0'
+                },
+                run: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { args }: any): Promise<void> {
+
+                        const env = await this.$ShellConfig.env
+                        const config = await this.WorkspaceConfig.config as any
+                        const cliConfig = await this.$WorkspaceCliConfig.config
+
+                        for (const name in env) {
+                            process.stdout.write(`export ${name}="${env[name]}"\n`)
+                        }
+
+                        process.stdout.write('\n')
+
+                        // Load the shell script template
+                        const shellScriptModule = import.meta.resolve('t44/caps/WorkspaceShell.sh')
+                        const shellScriptPath = shellScriptModule.replace('file://', '')
+                        let shellScript = await readFile(shellScriptPath, 'utf-8')
+
+                        // Generate commands dynamically from shell.commands
+                        const shellConfig = await this.$ShellConfig.config
+                        const shellCommands = shellConfig?.shell?.commands || {}
+                        const cliCommands = cliConfig?.cli?.commands || {}
+                        const commandNames = Object.keys(shellCommands).sort()
+
+                        // Generate shell functions
+                        const helpLines: string[] = []
+                        for (const cmdName of commandNames) {
+                            const cmdConfig = shellCommands[cmdName]
+
+                            let cmdBody = ''
+
+                            // Check if this is a cliCommand reference
+                            if (cmdConfig.cliCommand) {
+                                const cliCommandName = cmdConfig.cliCommand
+                                // Auto-generate the shell code to call the CLI command
+                                cmdBody = `(
+            cd "$F_WORKSPACE_DIR" &&
+            "\${F_WORKSPACE_IMPL_DIR}/bin/workspace" ${cliCommandName} \$@
+        )`
+                            } else {
+                                cmdBody = cmdConfig.cmd || ''
+                            }
+
+                            helpLines.push(`    function ${cmdName} {`)
+                            for (const line of cmdBody.split('\n')) {
+                                helpLines.push(`        ${line}`)
+                            }
+                            helpLines.push(`    }`)
+                            helpLines.push(``)
+                        }
+
+                        // Generate alias for h if it exists
+                        if (shellCommands.h) {
+                            helpLines.push(`    alias h='cd "\${F_WORKSPACE_DIR}"'`)
+                            helpLines.push(``)
+                        }
+
+                        const commandsBlock = helpLines.join('\n')
+
+                        // Replace the placeholder in the shell script
+                        shellScript = shellScript.replace('#${COMMANDS}', commandsBlock)
+
+                        // Remove the shebang line and output
+                        process.stdout.write(shellScript.split('\n').slice(1).join('\n'))
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/WorkspaceShell.v0'

package/caps/WorkspaceShell.yaml

@@ -0,0 +1,65 @@
+"#t44/structs/WorkspaceShellConfig.v0":
+  env:
+    default:
+    force:
+      F_WORKSPACE_DIR: resolve('${__dirname}/..')
+  shell:
+    commands:
+      help:
+        description: "Display help for shell commands."
+        cmd: |
+          "${F_WORKSPACE_IMPL_DIR}/bin/shell" --help
+      44:
+        description: "Run workspace CLI commands."
+        cmd: |
+          "${F_WORKSPACE_IMPL_DIR}/bin/workspace" $@
+      
+      a:
+        description: "Re-activate workspace environment."
+        cmd: |
+          w_log "start" "Re-activating workspace"
+
+          source "$F_WORKSPACE_ACTIVATE_BIN_PATH"
+
+          w_log "success" "Workspace Activated OK!"
+      
+      i:
+        description: "Re-install workspace dependencies (removes node_modules and runs bun install)."
+        cmd: |
+          w_log "start" "Re-installing workspace"
+
+          (
+              cd "${F_WORKSPACE_DIR}" && 
+              find . -name 'node_modules' -type d -prune -exec rm -rf {} + 2>/dev/null || true && 
+              bun install
+          )
+
+          w_log "success" "Workspace Re-installed OK!"
+      
+      info:
+        description: "Display workspace information."
+        cmd: |
+          (
+              cd "${F_WORKSPACE_DIR}" && 
+              "${F_WORKSPACE_IMPL_DIR}/bin/workspace" info ${@:2}
+          )
+
+      p:
+        description: "Push project repositories."
+        cmd: |
+          w_log "start" "Push project repositories"
+
+          (
+              cd "${F_WORKSPACE_DIR}" && 
+              "${F_WORKSPACE_IMPL_DIR}/bin/workspace" push $@
+          )
+
+          w_log "success" "Project repositories pushed OK!"
+      
+      h:
+        description: "Navigate to workspace home directory."
+        cmd: |
+          cd "${F_WORKSPACE_DIR}"
+
+      deploy:
+        cliCommand: "deploy"