@stream44.studio/t44 0.4.0-rc.24

package/caps/ProjectPulling.ts

@@ -0,0 +1,234 @@
+
+import { join, resolve } from 'path'
+import { $ } from 'bun'
+import chalk from 'chalk'
+
+// ── Provider Lifecycle Steps ─────────────────────────────────────────
+// Each pull provider capsule can implement these methods:
+//
+//   1. parseUrl     — parse a URL and return { owner, repo, branch } or null
+//   2. prepare      — clone/fetch the mirror repo, checkout the branch
+//   3. pull         — generate diff and apply to sourceDir
+//
+// Every method receives { config, ctx } where:
+//   config  = the provider's own config entry (with .capsule and .config)
+//   ctx     = shared pullingContext for the current operation
+
+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': {},
+            '#@stream44.studio/t44/structs/WorkspaceConfig': {
+                as: '$WorkspaceConfig'
+            },
+            '#@stream44.studio/t44/structs/ProjectPullingConfig': {
+                as: '$WorkspacePulling'
+            },
+            '#@stream44.studio/t44/structs/ProjectPublishingConfig': {
+                as: '$WorkspaceRepositories'
+            },
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspaceConfig'
+                },
+                ProjectRepository: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/ProjectRepository'
+                },
+                run: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { args }: any): Promise<void> {
+
+                        const { url } = args
+
+                        if (!url) {
+                            console.error(chalk.red('\n[t44] ERROR: A URL argument is required.'))
+                            console.error(chalk.red('  Usage: t44 pull <url>'))
+                            console.error(chalk.red('  Example: t44 pull https://github.com/Stream44/FramespaceGenesis/tree/fixes\n'))
+                            process.exit(1)
+                        }
+
+                        // ── Dynamic provider loader ──────────────────────────
+                        const providerCache = new Map<string, any>()
+                        const getProvider = async (uri: string) => {
+                            const cleanUri = uri.startsWith('#') ? uri.substring(1) : uri
+                            if (!providerCache.has(cleanUri)) {
+                                const { api } = await this.self.importCapsule({ uri: cleanUri })
+                                providerCache.set(cleanUri, api)
+                            }
+                            return providerCache.get(cleanUri)!
+                        }
+
+                        // ── Load pulling config ──────────────────────────────
+                        const pullingConfig = await this.$WorkspacePulling.config
+
+                        const globalProviders: any[] = Array.isArray(pullingConfig?.providers)
+                            ? pullingConfig.providers
+                            : []
+
+                        if (globalProviders.length === 0) {
+                            console.error(chalk.red('\n[t44] ERROR: No pulling providers configured.'))
+                            console.error(chalk.red('  Add providers under "#@stream44.studio/t44/structs/ProjectPullingConfig" in workspace.yaml\n'))
+                            process.exit(1)
+                        }
+
+                        // ── STEP 1: parseUrl — ask each provider to parse the URL ──
+                        console.log(`\n[t44] Parsing URL: ${chalk.cyan(url)}\n`)
+
+                        let parsedUrl: any = null
+                        let matchedProviderConfig: any = null
+
+                        for (const providerConfig of globalProviders) {
+                            if (providerConfig.enabled === false) continue
+
+                            const provider = await getProvider(providerConfig.capsule)
+                            if (typeof provider.parseUrl !== 'function') continue
+
+                            const result = await provider.parseUrl({ config: providerConfig, url })
+                            if (result) {
+                                parsedUrl = result
+                                matchedProviderConfig = providerConfig
+                                console.log(chalk.green(`   ✓ URL parsed by '${providerConfig.capsule}'`))
+                                console.log(chalk.gray(`     owner: ${result.owner}, repo: ${result.repo}, branch: ${result.branch}\n`))
+                                break
+                            }
+                        }
+
+                        if (!parsedUrl || !matchedProviderConfig) {
+                            console.error(chalk.red('\n[t44] ERROR: No pull provider could parse the URL.'))
+                            console.error(chalk.red(`  URL: ${url}`))
+                            console.error(chalk.red(`  Configured providers:`))
+                            for (const p of globalProviders) {
+                                console.error(chalk.red(`    - ${p.capsule} (enabled: ${p.enabled !== false})`))
+                            }
+                            console.error(chalk.red(`\n  Make sure a provider for this URL type is configured.\n`))
+                            process.exit(1)
+                        }
+
+                        // ── STEP 2: Find matching publishing repository ──────
+                        const publishingConfig = await this.$WorkspaceRepositories.config
+
+                        if (!publishingConfig?.repositories) {
+                            console.error(chalk.red('\n[t44] ERROR: No publishing repositories configured.'))
+                            console.error(chalk.red('  Cannot match URL to a local project without publishing config.\n'))
+                            process.exit(1)
+                        }
+
+                        let matchedRepoName: string | null = null
+                        let matchedRepoConfig: any = null
+
+                        for (const [repoName, repoConfig] of Object.entries(publishingConfig.repositories)) {
+                            const typedConfig = repoConfig as any
+                            const providers: any[] = Array.isArray(typedConfig.providers) ? typedConfig.providers : []
+
+                            for (const provider of providers) {
+                                // Match against GitHub publishing provider config
+                                if (provider.capsule === '@stream44.studio/t44-github.com/caps/ProjectPublishing') {
+                                    const settings = provider.config?.RepositorySettings
+                                    if (settings?.owner === parsedUrl.owner && settings?.repo === parsedUrl.repo) {
+                                        matchedRepoName = repoName
+                                        matchedRepoConfig = typedConfig
+                                        break
+                                    }
+                                }
+                            }
+                            if (matchedRepoName) break
+                        }
+
+                        if (!matchedRepoName || !matchedRepoConfig) {
+                            console.error(chalk.red(`\n[t44] ERROR: No matching publishing repository found for ${parsedUrl.owner}/${parsedUrl.repo}.`))
+                            console.error(chalk.red(`  The URL points to '${parsedUrl.owner}/${parsedUrl.repo}' but no repository in`))
+                            console.error(chalk.red(`  "#@stream44.studio/t44/structs/ProjectPublishingConfig" has a GitHub provider with matching owner/repo.`))
+                            console.error(chalk.red(`\n  Configured repositories:`))
+                            for (const rn of Object.keys(publishingConfig.repositories)) {
+                                console.error(chalk.red(`    - ${rn}`))
+                            }
+                            console.error('')
+                            process.exit(1)
+                        }
+
+                        const sourceDir = resolve(matchedRepoConfig.sourceDir)
+                        console.log(chalk.green(`   ✓ Matched repository: '${matchedRepoName}'`))
+                        console.log(chalk.gray(`     sourceDir: ${sourceDir}\n`))
+
+                        // ── STEP 3: prepare — ensure sourceDir has no uncommitted changes ──
+                        console.log('[t44] Preparing: checking for uncommitted changes ...\n')
+
+                        const statusResult = await $`git status --porcelain`.cwd(sourceDir).quiet().nothrow()
+                        const statusOutput = statusResult.text().trim()
+
+                        if (statusOutput.length > 0) {
+                            console.error(chalk.red(`\n[t44] ERROR: sourceDir has uncommitted changes. Commit or stash them first.`))
+                            console.error(chalk.red(`  sourceDir: ${sourceDir}`))
+                            console.error(chalk.red(`  Changes:\n`))
+                            for (const line of statusOutput.split('\n').slice(0, 20)) {
+                                console.error(chalk.red(`    ${line}`))
+                            }
+                            if (statusOutput.split('\n').length > 20) {
+                                console.error(chalk.red(`    ... and ${statusOutput.split('\n').length - 20} more`))
+                            }
+                            console.error('')
+                            process.exit(1)
+                        }
+
+                        console.log(chalk.green(`   ✓ sourceDir is clean\n`))
+
+                        // ── STEP 4: Set up mirror repo ───────────────────────
+                        // Reuse the publishing stage repo as a fast clone source if it exists.
+                        // The mirror lives in its own ProjectPulling projection dir.
+
+                        const pullingApi = {
+                            getProjectionDir: (capsuleName: string) => join(
+                                this.WorkspaceConfig.workspaceRootDir,
+                                '.~o/workspace.foundation/@t44.sh~t44~caps~ProjectPulling',
+                                capsuleName.replace(/\//g, '~')
+                            ),
+                        }
+
+                        const ctx = {
+                            parsedUrl,
+                            matchedRepoName,
+                            matchedRepoConfig,
+                            sourceDir,
+                            publishingConfig,
+                            pullingApi,
+                            metadata: {} as Record<string, any>,
+                        }
+
+                        // ── STEP 5: Call provider prepare + pull ─────────────
+                        const provider = await getProvider(matchedProviderConfig.capsule)
+
+                        if (typeof provider.prepare === 'function') {
+                            console.log('[t44] Preparing mirror repository ...\n')
+                            await provider.prepare({ config: matchedProviderConfig, ctx })
+                        }
+
+                        if (typeof provider.pull !== 'function') {
+                            console.error(chalk.red(`\n[t44] ERROR: Provider '${matchedProviderConfig.capsule}' does not implement 'pull'.`))
+                            process.exit(1)
+                        }
+
+                        console.log('[t44] Pulling changes ...\n')
+                        await provider.pull({ config: matchedProviderConfig, ctx })
+
+                        console.log(chalk.green('\n[t44] Pull complete!'))
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/ProjectPulling'

package/caps/ProjectRack.ts

@@ -0,0 +1,155 @@
+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': {},
+            '#@stream44.studio/t44/structs/WorkspaceConfig': {
+                as: '$WorkspaceConfig'
+            },
+            '#@stream44.studio/t44/structs/ProjectRackConfig': {
+                as: '$ProjectRackConfig'
+            },
+            '#': {
+                WorkspacePrompt: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspacePrompt'
+                },
+                HomeRegistry: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/HomeRegistry'
+                },
+                ensureRack: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<{ rackName: string }> {
+                        const workspaceConfig = await this.$WorkspaceConfig.config
+                        const rackConfig = await this.$ProjectRackConfig.config
+
+                        // Check if projectRack is already set in config (object format: { name, identifier })
+                        if (rackConfig?.name && rackConfig?.identifier) {
+                            return { rackName: rackConfig.name }
+                        }
+
+                        let rackName: string
+
+                        const rackConfigStructKey = '#@stream44.studio/t44/structs/ProjectRackConfig'
+                        if (!rackConfig?.name) {
+                            const chalk = (await import('chalk')).default
+
+                            console.log(chalk.cyan(`\n📦 Project Rack Setup\n`))
+                            console.log(chalk.gray(`   Workspace: ${workspaceConfig?.name || 'unknown'}`))
+                            console.log(chalk.gray(`   Root: ${workspaceConfig?.rootDir || 'unknown'}`))
+                            console.log(chalk.gray(''))
+                            console.log(chalk.gray('   The project rack holds an integrated set of projects which can be'))
+                            console.log(chalk.gray('   pulled into one or more workspaces.'))
+                            console.log(chalk.gray('   A workspace attached to a rack has access to all projects in the rack'))
+                            console.log(chalk.gray('   and is able to add more projects to the rack.'))
+                            console.log(chalk.gray('   All workspaces attached to a rack automatically sync their projects'))
+                            console.log(chalk.gray('   to the rack.'))
+                            console.log(chalk.gray(''))
+
+                            // List existing project racks from registry
+                            const existingRacks = await this.HomeRegistry.listRacks()
+
+                            // Build choices
+                            const choices: Array<{ name: string; value: any }> = []
+
+                            for (const rack of existingRacks) {
+                                choices.push({
+                                    name: `${rack.name}  ${chalk.gray(rack.did ? rack.did.substring(0, 50) + '...' : '')}`,
+                                    value: { type: 'existing', name: rack.name }
+                                })
+                            }
+
+                            choices.push({
+                                name: chalk.yellow('+ Create a new project rack'),
+                                value: { type: 'create' }
+                            })
+
+                            const selected = await this.WorkspacePrompt.select({
+                                message: 'Select a project rack:',
+                                choices,
+                                defaultValue: { type: 'create' },
+                                pageSize: 15
+                            })
+
+                            if (selected.type === 'existing') {
+                                rackName = selected.name
+                            } else {
+                                // Prompt for rack name
+                                rackName = await this.WorkspacePrompt.input({
+                                    message: 'Enter a name for the new project rack:',
+                                    defaultValue: workspaceConfig?.name || 'genesis',
+                                    validate: (input: string) => {
+                                        if (!input || input.trim().length === 0) {
+                                            return 'Project rack name cannot be empty'
+                                        }
+                                        if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
+                                            return 'Project rack name can only contain letters, numbers, underscores, and hyphens'
+                                        }
+                                        return true
+                                    }
+                                })
+                            }
+                        } else {
+                            rackName = rackConfig.name
+                        }
+
+                        // Check if rack already exists in registry
+                        let rackData = await this.HomeRegistry.getRack(rackName)
+
+                        if (!rackData) {
+                            const chalk = (await import('chalk')).default
+                            console.log(chalk.cyan(`\n   Registering project rack '${rackName}'...\n`))
+
+                            const { generateKeypair } = await import('../lib/ucan.js')
+                            const { did, privateKey } = await generateKeypair()
+
+                            rackData = {
+                                did,
+                                privateKey,
+                                createdAt: new Date().toISOString()
+                            }
+
+                            const rackPath = await this.HomeRegistry.setRack(rackName, rackData)
+
+                            console.log(chalk.green(`   ✓ Project rack registered at:`))
+                            console.log(chalk.green(`     ${rackPath}`))
+                            console.log(chalk.green(`   ✓ DID: ${rackData.did}\n`))
+                        } else {
+                            const chalk = (await import('chalk')).default
+                            const rackPath = await this.HomeRegistry.getRackPath(rackName)
+                            console.log(chalk.green(`\n   ✓ Using existing project rack at:`))
+                            console.log(chalk.green(`     ${rackPath}`))
+                            console.log(chalk.green(`   ✓ DID: ${rackData.did}\n`))
+                        }
+
+                        // Store rack as object { name, identifier } in rack config struct
+                        await this.$ProjectRackConfig.setConfigValue(['name'], rackName)
+                        await this.$ProjectRackConfig.setConfigValue(['identifier'], rackData.did)
+
+                        return { rackName }
+                    }
+                },
+                getRackName: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<string | null> {
+                        const rackConfig = await this.$ProjectRackConfig.config
+                        return rackConfig?.name || null
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/ProjectRack'