t44 0.2.0-rc.1

package/caps/ProjectPublishing.v0.ts

@@ -0,0 +1,307 @@
+
+import { join } from 'path'
+import { $ } from 'bun'
+import { mkdir, access, readFile, writeFile } from 'fs/promises'
+import { constants } from 'fs'
+import chalk from 'chalk'
+
+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/WorkspaceConfig.v0': {
+                as: '$WorkspaceConfig'
+            },
+            '#t44/structs/WorkspaceRepositories.v0': {
+                as: '$WorkspaceRepositories'
+            },
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceConfig.v0'
+                },
+                WorkspaceProjects: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceProjects.v0'
+                },
+                GitRepository: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/providers/git-scm.com/ProjectPublishing.v0'
+                },
+                NpmRegistry: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/providers/npmjs.com/ProjectPublishing.v0'
+                },
+                GitHubRepository: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/providers/github.com/ProjectPublishing.v0'
+                },
+                run: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { args }: any): Promise<void> {
+
+                        const { projectSelector, rc, release, dangerouslyResetMain } = args
+
+                        const repositoriesConfig = await this.$WorkspaceRepositories.config
+
+                        if (!repositoriesConfig?.repositories) {
+                            throw new Error('No repositories configuration found')
+                        }
+
+                        if (dangerouslyResetMain && !projectSelector) {
+                            throw new Error('--dangerously-reset-main flag requires a projectSelector to be specified')
+                        }
+
+                        let matchingRepositories: Record<string, any>
+
+                        if (!projectSelector) {
+                            matchingRepositories = repositoriesConfig.repositories
+                        } else {
+                            matchingRepositories = await this.WorkspaceProjects.resolveMatchingRepositories({
+                                workspaceProject: projectSelector,
+                                repositories: repositoriesConfig.repositories
+                            })
+                        }
+
+                        // Phase 0: Copy source directories to central location
+                        console.log('[t44] Copying source directories to central location ...\n')
+                        const centralSourceDirs: Map<string, string> = new Map()
+
+                        for (const [repoName, repoConfig] of Object.entries(matchingRepositories)) {
+                            const projectSourceDir = join((repoConfig as any).sourceDir)
+                            const repoSourceDir = join(
+                                this.WorkspaceConfig.workspaceRootDir,
+                                '.~o/workspace.foundation/ProjectPublishing/repos',
+                                repoName
+                            )
+
+                            console.log(`=> Syncing '${repoName}' to central location ...`)
+
+                            await mkdir(repoSourceDir, { recursive: true })
+
+                            const gitignorePath = join(projectSourceDir, '.gitignore')
+                            let gitignoreExists = false
+                            try {
+                                await access(gitignorePath, constants.F_OK)
+                                gitignoreExists = true
+                            } catch { }
+
+                            const rsyncArgs = ['rsync', '-a', '--delete', '--exclude', '.git']
+                            if (gitignoreExists) rsyncArgs.push('--exclude-from=' + gitignorePath)
+                            rsyncArgs.push(projectSourceDir + '/', repoSourceDir + '/')
+                            await $`${rsyncArgs}`
+
+                            centralSourceDirs.set(repoName, repoSourceDir)
+                            console.log(`   Synced to: ${repoSourceDir}\n`)
+                        }
+
+                        // Helper to iterate providers with custom callback
+                        const forEachProvider = async (callback: (params: {
+                            repoName: string,
+                            repoConfig: any,
+                            providerConfig: any,
+                            capsuleName: string,
+                            repoSourceDir: string
+                        }) => Promise<void>) => {
+                            for (const [repoName, repoConfig] of Object.entries(matchingRepositories)) {
+                                const providers = Array.isArray((repoConfig as any).providers)
+                                    ? (repoConfig as any).providers
+                                    : (repoConfig as any).provider
+                                        ? [(repoConfig as any).provider]
+                                        : []
+
+                                const repoSourceDir = centralSourceDirs.get(repoName)!
+                                for (const providerConfig of providers) {
+                                    const capsuleName = providerConfig.capsule
+                                    await callback({ repoName, repoConfig, providerConfig, capsuleName, repoSourceDir })
+                                }
+                            }
+                        }
+
+                        // Phase 1: Prepare - analyze all packages and collect metadata
+                        console.log('[t44] Analyzing packages ...\n')
+                        const packageMetadata: Map<string, any> = new Map()
+
+                        await forEachProvider(async ({ repoName, repoConfig, providerConfig, capsuleName, repoSourceDir }) => {
+                            if (capsuleName === 't44/caps/providers/npmjs.com/ProjectPublishing.v0') {
+                                const metadata = await this.NpmRegistry.prepare({
+                                    config: { ...repoConfig, provider: providerConfig, sourceDir: repoSourceDir },
+                                    projectionDir: join(
+                                        this.WorkspaceConfig.workspaceRootDir,
+                                        '.~o/workspace.foundation/o/npmjs.com'
+                                    ),
+                                    repoSourceDir
+                                })
+                                packageMetadata.set(repoName, metadata)
+                            }
+                        })
+
+                        // Phase 2: Bump - only bump packages that have changes
+                        if (rc || release) {
+                            if (rc) console.log('[t44] Release candidate mode enabled\n')
+                            if (release) console.log('[t44] Release mode enabled\n')
+
+                            console.log('[t44] Bumping versions for changed packages ...\n')
+
+                            const bumpedRepos = new Set<string>()
+                            await forEachProvider(async ({ repoName, repoConfig, providerConfig, capsuleName, repoSourceDir }) => {
+                                if (capsuleName === 't44/caps/providers/npmjs.com/ProjectPublishing.v0') {
+                                    const metadata = packageMetadata.get(repoName)
+
+                                    if (metadata && metadata.hasChanges) {
+                                        if (!bumpedRepos.has(repoName)) {
+                                            console.log(`\n=> Bumping version for '${repoName}' ...\n`)
+                                            bumpedRepos.add(repoName)
+                                        }
+
+                                        await this.NpmRegistry.bump({
+                                            config: { ...repoConfig, provider: providerConfig },
+                                            options: { rc, release },
+                                            repoSourceDir,
+                                            metadata
+                                        })
+                                    } else if (metadata && !bumpedRepos.has(repoName)) {
+                                        console.log(`\n=> Skipping '${repoName}' (no changes)\n`)
+                                        bumpedRepos.add(repoName)
+                                    }
+                                }
+                            })
+
+                            console.log('[t44] Version bump complete!\n')
+
+                            // Tag git-scm repos with the bumped version
+                            const taggedRepos = new Set<string>()
+                            await forEachProvider(async ({ repoName, repoConfig, providerConfig, capsuleName, repoSourceDir }) => {
+                                if (capsuleName === 't44/caps/providers/git-scm.com/ProjectPublishing.v0' && !taggedRepos.has(repoName)) {
+                                    // Read the bumped version from the source package.json
+                                    const packageJsonPath = join(repoSourceDir, 'package.json')
+                                    try {
+                                        const packageJsonContent = await readFile(packageJsonPath, 'utf-8')
+                                        const packageJson = JSON.parse(packageJsonContent)
+                                        const version = packageJson.version
+                                        const tag = `v${version}`
+
+                                        const originUri = providerConfig.config.RepositorySettings.origin
+                                        const projectionDir = join(
+                                            this.WorkspaceConfig.workspaceRootDir,
+                                            '.~o/workspace.foundation/o/git-scm.com'
+                                        )
+                                        const projectProjectionDir = join(projectionDir, 'repos', originUri.replace(/[@:\/]/g, '~'))
+
+                                        // Check if the projection repo exists
+                                        try {
+                                            await access(projectProjectionDir, constants.F_OK)
+                                        } catch {
+                                            // Repo not cloned yet, tagging will happen after push
+                                            return
+                                        }
+
+                                        // Check if tag already exists locally or on remote
+                                        const localTagCheck = await $`git tag -l ${tag}`.cwd(projectProjectionDir).quiet().nothrow()
+                                        if (localTagCheck.text().trim() === tag) {
+                                            throw new Error(
+                                                `Git tag '${tag}' already exists in repository '${repoName}'.\n` +
+                                                `  Please bump to a different version before pushing.`
+                                            )
+                                        }
+
+                                        const remoteTagCheck = await $`git ls-remote --tags origin ${tag}`.cwd(projectProjectionDir).quiet().nothrow()
+                                        if (remoteTagCheck.text().trim().length > 0) {
+                                            throw new Error(
+                                                `Git tag '${tag}' already exists on remote for repository '${repoName}'.\n` +
+                                                `  Please bump to a different version before pushing.`
+                                            )
+                                        }
+
+                                        await $`git tag ${tag}`.cwd(projectProjectionDir)
+                                        console.log(chalk.green(`  ✓ Tagged repository '${repoName}' with ${tag}\n`))
+                                        taggedRepos.add(repoName)
+                                    } catch (error: any) {
+                                        if (error.message?.includes('already exists')) {
+                                            throw error
+                                        }
+                                        // Skip if package.json can't be read
+                                    }
+                                }
+                            })
+
+                            await forEachProvider(async ({ repoName, repoConfig, providerConfig, capsuleName, repoSourceDir }) => {
+                                if (capsuleName === 't44/caps/providers/npmjs.com/ProjectPublishing.v0') {
+                                    const metadata = await this.NpmRegistry.prepare({
+                                        config: { ...repoConfig, provider: providerConfig, sourceDir: repoSourceDir },
+                                        projectionDir: join(
+                                            this.WorkspaceConfig.workspaceRootDir,
+                                            '.~o/workspace.foundation/o/npmjs.com'
+                                        ),
+                                        repoSourceDir
+                                    })
+                                    packageMetadata.set(repoName, metadata)
+                                }
+                            })
+                        }
+
+                        // Phase 3: Push - publish packages
+                        console.log('[t44] Publishing packages ...\n')
+
+                        const processedRepos = new Set<string>()
+                        await forEachProvider(async ({ repoName, repoConfig, providerConfig, capsuleName, repoSourceDir }) => {
+                            if (!processedRepos.has(repoName)) {
+                                console.log(`\n=> Processing repository '${repoName}' ...\n`)
+                                processedRepos.add(repoName)
+                            }
+
+                            console.log(`  -> Running provider '${capsuleName}' ...\n`)
+
+                            const metadata = packageMetadata.get(repoName)
+
+                            if (capsuleName === 't44/caps/providers/github.com/ProjectPublishing.v0') {
+                                await this.GitHubRepository.push({
+                                    config: { ...repoConfig, provider: providerConfig, sourceDir: repoSourceDir }
+                                })
+                            } else if (capsuleName === 't44/caps/providers/git-scm.com/ProjectPublishing.v0') {
+                                await this.GitRepository.push({
+                                    config: { ...repoConfig, provider: providerConfig, sourceDir: repoSourceDir },
+                                    projectionDir: join(
+                                        this.WorkspaceConfig.workspaceRootDir,
+                                        '.~o/workspace.foundation/o/git-scm.com'
+                                    ),
+                                    dangerouslyResetMain
+                                })
+                            } else if (capsuleName === 't44/caps/providers/npmjs.com/ProjectPublishing.v0') {
+                                await this.NpmRegistry.push({
+                                    config: { ...repoConfig, provider: providerConfig, sourceDir: repoSourceDir },
+                                    projectionDir: join(
+                                        this.WorkspaceConfig.workspaceRootDir,
+                                        '.~o/workspace.foundation/o/npmjs.com'
+                                    ),
+                                    metadata
+                                })
+                            }
+
+                            console.log(`  <- Provider '${capsuleName}' complete.\n`)
+                        })
+
+                        for (const repoName of processedRepos) {
+                            console.log(`<= Repository '${repoName}' processing complete.\n`)
+                        }
+
+                        console.log('[t44] Project repositories pushed OK!')
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/ProjectPublishing.v0'

package/caps/ProjectRack.v0.ts

@@ -0,0 +1,128 @@
+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/WorkspaceConfig.v0': {
+                as: '$WorkspaceConfig'
+            },
+            '#t44/structs/ProjectRackConfig.v0': {
+                as: '$ProjectRackConfig'
+            },
+            '#': {
+                WorkspacePrompt: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspacePrompt.v0'
+                },
+                HomeRegistry: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/HomeRegistry.v0'
+                },
+                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 = '#t44/structs/ProjectRackConfig.v0'
+                        if (!rackConfig?.name) {
+                            rackName = await this.WorkspacePrompt.setupPrompt({
+                                title: '📦 Project Rack Setup',
+                                description: [
+                                    `Workspace: ${workspaceConfig?.name || 'unknown'}`,
+                                    `Root: ${workspaceConfig?.rootDir || 'unknown'}`,
+                                    '',
+                                    'The project rack holds an integrated set of projects which can be',
+                                    'pulled into one or more workspaces.',
+                                    'A workspace attached to a rack has access to all projects in the rack',
+                                    'and is able to add more projects to the rack.',
+                                    'All workspaces attached to a rack automatically sync their projects',
+                                    'to the rack.',
+                                    '',
+                                ],
+                                message: 'Enter a name for the project rack:',
+                                defaultValue: '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
+                                },
+                                configPath: [rackConfigStructKey],
+                                onSuccess: async () => {
+                                    // Don't write to config yet — we write the full object after rack registration
+                                }
+                            })
+                        } 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['#'] = 't44/caps/ProjectRack.v0'