@cubis/foundry 0.3.11 → 0.3.13

package/Ai Agent Workflow/workflows/agent-environment-setup/platforms/windsurf/skills/vercel-storage/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: vercel-storage
+description: "Vercel Storage solutions: Blob for file storage, Marketplace Postgres, Marketplace Redis, and storage migration strategies between providers."
+license: MIT
+metadata:
+  author: cubis-foundry
+  version: "1.0.0"
+  domain: vercel
+  triggers: vercel, storage, blob, postgres, redis, kv, storage migration, file upload, vercel blob, vercel postgres, vercel redis
+  role: specialist
+  scope: implementation
+  output-format: checklist
+  related-skills: database-design, database-optimizer, vercel-functions, vercel-deployments
+  consolidates: vercel-blob, vercel-marketplace-storage-postgres, vercel-marketplace-storage-redis, vercel-storage-migrations
+---
+
+# Vercel Storage
+
+## Purpose
+Implement and manage Vercel Storage solutions including Blob for file/object storage, Marketplace Postgres for relational data, Marketplace Redis for caching/session state, and strategies for migrating between storage providers.
+
+## When To Use
+- Storing user-uploaded files, assets, or binary objects with Vercel Blob.
+- Provisioning a managed Postgres database via Vercel Marketplace.
+- Using managed Redis for session storage, caching, or pub/sub.
+- Migrating existing storage workloads onto or off Vercel-managed storage.
+
+## Domain Areas
+
+### Vercel Blob
+- Upload, list, and delete blobs with `@vercel/blob` SDK.
+- Client-side uploads using multipart upload tokens.
+- Set Content-Type, cache-control, and access control.
+- Integrate blob URLs with CDN delivery.
+
+### Marketplace Postgres
+- Provision and connect via `POSTGRES_URL` environment variable.
+- Use with Prisma, Drizzle, or `pg`/`postgres` client.
+- Connection pooling with Vercel Postgres connection pool.
+- Schema migrations and backup strategy.
+
+### Marketplace Redis
+- Connect via `KV_URL` / `REDIS_URL` environment variable.
+- Use `@vercel/kv` SDK or `ioredis` for session state, queues, and rate limiting.
+- Understand persistence and eviction policy defaults.
+- Multi-region replication considerations.
+
+### Storage Migrations
+- Audit current storage usage volume and access patterns.
+- Plan zero-downtime migration with dual-write phase.
+- Validate data integrity post-migration before cutover.
+
+## Operating Checklist
+1. Choose storage type based on access pattern (object vs relational vs KV).
+2. Inject connection strings via environment variables (never hard-code).
+3. Set appropriate TTL/eviction policies for Redis.
+4. Validate connection pooling config for Postgres under load.
+5. Run migration dry-run and verify checksums before full cutover.
+6. Enable auto-backup or export schedule for production data.
+
+## Output Contract
+- Storage selection rationale and architecture
+- SDK integration code and environment variable setup
+- Connection pooling and scaling configuration
+- Migration plan with dry-run and rollback steps
+- Residual risks and data integrity validation evidence

package/README.md

@@ -36,6 +36,10 @@ cbx workflows install --platform antigravity --dry-run
 cbx workflows install --platform antigravity --terminal-integration --terminal-verifier codex
 ```
 
+Install bootstrap behavior:
+- `cbx workflows install` now also bootstraps `ENGINEERING_RULES.md` and `TECH.md` (creates when missing; keeps existing files unless explicitly regenerated).
+- Use `cbx rules init --platform <platform> --overwrite` to force-regenerate both files.
+
 `rules` manages strict engineering policy and a generated codebase tech map:
 
 ```bash
@@ -83,6 +87,13 @@ Bundle contains platform-specific:
 
 ## Installed Capability Set (v1)
 
+Database capability stack:
+- `database-skills` (engine hub)
+- `database-design` (schema/migration design)
+- `database-optimizer` (query/index/tuning triage)
+- `drift-flutter` (Flutter local persistence)
+
+
 Core workflows:
 - `/brainstorm`
 - `/plan`

package/bin/cubis.js

@@ -2882,6 +2882,14 @@ async function runWorkflowInstall(options) {
       dryRun,
       cwd: process.cwd()
     });
+    const engineeringArtifactsResult = await upsertEngineeringArtifacts({
+      platform,
+      scope,
+      overwrite: false,
+      dryRun,
+      skipTech: false,
+      cwd: process.cwd()
+    });
 
     const terminalVerificationRuleResult =
       platform === "antigravity" && installResult.terminalIntegration
@@ -2918,6 +2926,10 @@ async function runWorkflowInstall(options) {
       dryRun
     });
     printRuleSyncResult(syncResult);
+    printInstallEngineeringSummary({
+      engineeringResults: engineeringArtifactsResult.engineeringResults,
+      techResult: engineeringArtifactsResult.techResult
+    });
     if (dryRun) {
       console.log("\nDry-run complete. Re-run without `--dry-run` to apply changes.");
     } else {
@@ -3128,6 +3140,94 @@ function printRulesInitSummary({
   }
 }
 
+function printInstallEngineeringSummary({ engineeringResults, techResult }) {
+  console.log("\nEngineering artifacts:");
+  for (const item of engineeringResults) {
+    console.log(`- ENGINEERING_RULES.md: ${item.rulesFileResult.action} (${item.rulesFilePath})`);
+    console.log(`- Managed engineering block (${item.ruleFilePath}): ${item.blockResult.action}`);
+    if (item.blockResult.warnings.length > 0) {
+      for (const warning of item.blockResult.warnings) {
+        console.log(`  - warning: ${warning}`);
+      }
+    }
+  }
+
+  if (techResult) {
+    console.log(`- TECH.md: ${techResult.action} (${techResult.filePath})`);
+    console.log(`- TECH scan files: ${techResult.snapshot.scannedFiles}`);
+  }
+}
+
+async function upsertEngineeringArtifacts({
+  platform,
+  scope,
+  overwrite = false,
+  skipTech = false,
+  dryRun = false,
+  cwd = process.cwd()
+}) {
+  const ruleFilePath = await resolveRuleFilePath(platform, scope, cwd);
+  if (!ruleFilePath) throw new Error(`No rule file configured for platform '${platform}'.`);
+
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  const techMdPath = path.join(workspaceRoot, "TECH.md");
+  const targets = [{ ruleFilePath }];
+
+  if (scope === "global") {
+    const workspaceRuleFile = await resolveWorkspaceRuleFileForGlobalScope(platform, cwd);
+    const globalRuleFile = expandPath(WORKFLOW_PROFILES[platform].global.ruleFilesByPriority[0], cwd);
+    if (workspaceRuleFile && path.resolve(workspaceRuleFile) !== path.resolve(globalRuleFile)) {
+      targets.push({ ruleFilePath: workspaceRuleFile });
+    }
+  }
+
+  const template = buildEngineeringRulesTemplate();
+  const engineeringResults = [];
+  for (const target of targets) {
+    const rulesFilePath = path.join(path.dirname(target.ruleFilePath), "ENGINEERING_RULES.md");
+    const rulesFileResult = await writeTextFile({
+      targetPath: rulesFilePath,
+      content: `${template}\n`,
+      overwrite,
+      dryRun
+    });
+    const blockResult = await upsertEngineeringRulesBlock({
+      ruleFilePath: target.ruleFilePath,
+      platform,
+      engineeringRulesFilePath: rulesFilePath,
+      techMdFilePath: techMdPath,
+      dryRun
+    });
+    engineeringResults.push({
+      ruleFilePath: target.ruleFilePath,
+      rulesFilePath,
+      rulesFileResult,
+      blockResult
+    });
+  }
+
+  let techResult = null;
+  if (!skipTech) {
+    const snapshot = await collectTechSnapshot(workspaceRoot);
+    const content = buildTechMd(snapshot);
+    const fileResult = await writeTextFile({
+      targetPath: techMdPath,
+      content: `${content}\n`,
+      overwrite,
+      dryRun
+    });
+    techResult = {
+      ...fileResult,
+      snapshot
+    };
+  }
+
+  return {
+    engineeringResults,
+    techResult
+  };
+}
+
 async function runRulesInit(options) {
   try {
     const scope = normalizeScope(options.scope);
@@ -3135,68 +3235,21 @@ async function runRulesInit(options) {
     const overwrite = Boolean(options.overwrite);
     const cwd = process.cwd();
     const platform = await resolvePlatform(options.platform, scope, cwd);
-    const ruleFilePath = await resolveRuleFilePath(platform, scope, cwd);
-    if (!ruleFilePath) throw new Error(`No rule file configured for platform '${platform}'.`);
-
-    const workspaceRoot = findWorkspaceRoot(cwd);
-    const techMdPath = path.join(workspaceRoot, "TECH.md");
-    const targets = [{ ruleFilePath }];
-
-    if (scope === "global") {
-      const workspaceRuleFile = await resolveWorkspaceRuleFileForGlobalScope(platform, cwd);
-      const globalRuleFile = expandPath(WORKFLOW_PROFILES[platform].global.ruleFilesByPriority[0], cwd);
-      if (workspaceRuleFile && path.resolve(workspaceRuleFile) !== path.resolve(globalRuleFile)) {
-        targets.push({ ruleFilePath: workspaceRuleFile });
-      }
-    }
-
-    const template = buildEngineeringRulesTemplate();
-    const engineeringResults = [];
-    for (const target of targets) {
-      const rulesFilePath = path.join(path.dirname(target.ruleFilePath), "ENGINEERING_RULES.md");
-      const rulesFileResult = await writeTextFile({
-        targetPath: rulesFilePath,
-        content: `${template}\n`,
-        overwrite,
-        dryRun
-      });
-      const blockResult = await upsertEngineeringRulesBlock({
-        ruleFilePath: target.ruleFilePath,
-        platform,
-        engineeringRulesFilePath: rulesFilePath,
-        techMdFilePath: techMdPath,
-        dryRun
-      });
-      engineeringResults.push({
-        ruleFilePath: target.ruleFilePath,
-        rulesFilePath,
-        rulesFileResult,
-        blockResult
-      });
-    }
-
-    let techResult = null;
-    if (!options.skipTech) {
-      const snapshot = await collectTechSnapshot(workspaceRoot);
-      const content = buildTechMd(snapshot);
-      const fileResult = await writeTextFile({
-        targetPath: techMdPath,
-        content: `${content}\n`,
-        overwrite,
-        dryRun
-      });
-      techResult = {
-        ...fileResult,
-        snapshot
-      };
-    }
+    const initResult = await upsertEngineeringArtifacts({
+      platform,
+      scope,
+      overwrite,
+      skipTech: Boolean(options.skipTech),
+      dryRun,
+      cwd
+    });
 
     printRulesInitSummary({
       platform,
       scope,
       dryRun,
-      engineeringResults,
-      techResult
+      engineeringResults: initResult.engineeringResults,
+      techResult: initResult.techResult
     });
 
     if (dryRun) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubis/foundry",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Cubis Foundry CLI for workflow-first AI agent environments",
   "type": "module",
   "bin": {
@@ -20,7 +20,11 @@
     "test:attributes:strict": "node scripts/validate-platform-attributes.mjs --strict",
     "test:smoke": "bash scripts/smoke-workflows.sh",
     "test:all": "npm run test:attributes && npm run test:smoke",
-    "test:all:strict": "npm run test:attributes:strict && npm run test:smoke"
+    "test:all:strict": "npm run test:attributes:strict && npm run test:smoke",
+    "generate:powers": "node \"Ai Agent Workflow/scripts/generate-powers.mjs\"",
+    "generate:powers:force": "node \"Ai Agent Workflow/scripts/generate-powers.mjs\" --force",
+    "generate:powers:from-skills": "node \"Ai Agent Workflow/scripts/generate-powers.mjs\" --from-skills",
+    "generate:powers:sync": "node \"Ai Agent Workflow/scripts/generate-powers.mjs\" --sync-skills --force"
   },
   "engines": {
     "node": ">=18.17"

package/Ai Agent Workflow/powers/mongoose-nestjs/POWER.md

@@ -1,211 +0,0 @@
----
-name: mongoose-nestjs
-displayName: Mongoose NestJS
-description: Mongoose integration with NestJS including schema design, repository pattern, transactions, migrations, and multi-tenancy. Use for MongoDB database layer implementation.
-keywords:
-  - Mongoose
-  - MongoDB
-  - NestJS Mongoose
-  - schema
-  - repository pattern
-  - transactions
-  - ODM
-author: OneUp
----
-
-# Mongoose NestJS
-
-## Overview
-
-Expert guidance for integrating Mongoose with NestJS applications. Covers schema design, repository pattern implementation, transaction handling, data migrations, and multi-tenant architecture patterns.
-
-## Role Definition
-
-You are a database specialist with deep expertise in MongoDB and Mongoose ODM. You design efficient schemas, implement clean repository abstractions, and ensure data integrity through proper transaction handling.
-
-## When to Use This Power
-
-- Designing Mongoose schemas for NestJS
-- Implementing repository pattern with Mongoose
-- Handling MongoDB transactions
-- Creating database migrations
-- Setting up multi-tenant data isolation
-- Optimizing Mongoose queries
-
-## Core Workflow
-
-1. **Design Schema** - Define document structure with proper types and indexes
-2. **Create Repository** - Implement data access layer with base repository
-3. **Add Transactions** - Wrap critical operations in transactions
-4. **Write Migrations** - Version schema changes
-5. **Test** - Verify data integrity and performance
-
-## Available Steering Files
-
-| Topic              | Reference                        | Load When                                      |
-| ------------------ | -------------------------------- | ---------------------------------------------- |
-| Schema Design      | `steering/schema-design.md`      | Creating schemas, indexes, virtuals, hooks     |
-| Repository Pattern | `steering/repository-pattern.md` | Base repository, custom queries, pagination    |
-| Transactions       | `steering/transactions.md`       | ACID operations, retry logic, session handling |
-| Migrations         | `steering/migrations.md`         | Schema versioning, data migrations             |
-
-## Quick Reference
-
-### Module Setup
-
-```typescript
-// app.module.ts
-import { Module } from "@nestjs/common";
-import { MongooseModule } from "@nestjs/mongoose";
-import { ConfigModule, ConfigService } from "@nestjs/config";
-
-@Module({
-  imports: [
-    MongooseModule.forRootAsync({
-      imports: [ConfigModule],
-      useFactory: (config: ConfigService) => ({
-        uri: config.get<string>("MONGO_URL"),
-        // Connection options
-        maxPoolSize: 10,
-        serverSelectionTimeoutMS: 5000,
-        socketTimeoutMS: 45000,
-      }),
-      inject: [ConfigService],
-    }),
-  ],
-})
-export class AppModule {}
-```
-
-### Schema Definition
-
-```typescript
-// user.schema.ts
-import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
-import { Document, Types } from "mongoose";
-
-export type UserDocument = User & Document;
-
-@Schema({
-  timestamps: true,
-  collection: "users",
-})
-export class User {
-  @Prop({ required: true, unique: true, index: true })
-  username: string;
-
-  @Prop({ required: true, select: false })
-  password: string;
-
-  @Prop({ required: true, index: true })
-  organizationId: string;
-
-  @Prop({ type: String, enum: ["SUPER_ADMIN", "ADMIN", "STAFF"] })
-  role: string;
-
-  @Prop({ default: true })
-  enabled: boolean;
-}
-
-export const UserSchema = SchemaFactory.createForClass(User);
-
-// Add indexes
-UserSchema.index({ organizationId: 1, role: 1 });
-UserSchema.index({ username: "text", name: "text" });
-```
-
-### Feature Module
-
-```typescript
-// users.module.ts
-import { Module } from "@nestjs/common";
-import { MongooseModule } from "@nestjs/mongoose";
-import { User, UserSchema } from "./schemas/user.schema";
-import { UsersController } from "./users.controller";
-import { UsersService } from "./users.service";
-import { UsersRepository } from "./users.repository";
-
-@Module({
-  imports: [
-    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
-  ],
-  controllers: [UsersController],
-  providers: [UsersService, UsersRepository],
-  exports: [UsersService],
-})
-export class UsersModule {}
-```
-
-### Repository Pattern
-
-```typescript
-// users.repository.ts
-import { Injectable, Logger } from "@nestjs/common";
-import { InjectModel } from "@nestjs/mongoose";
-import { Model, ClientSession } from "mongoose";
-import { User, UserDocument } from "./schemas/user.schema";
-
-@Injectable()
-export class UsersRepository {
-  private readonly logger = new Logger(UsersRepository.name);
-
-  constructor(
-    @InjectModel(User.name)
-    private readonly model: Model<UserDocument>,
-  ) {}
-
-  async create(
-    data: Partial<User>,
-    session?: ClientSession,
-  ): Promise<UserDocument> {
-    const user = new this.model(data);
-    return user.save({ session });
-  }
-
-  async findById(
-    id: string,
-    session?: ClientSession,
-  ): Promise<UserDocument | null> {
-    return this.model.findById(id).session(session).exec();
-  }
-
-  async findByUsername(username: string): Promise<UserDocument | null> {
-    return this.model.findOne({ username }).select("+password").exec();
-  }
-}
-```
-
-## Constraints
-
-### MUST DO
-
-- Use `@nestjs/mongoose` decorators for schemas
-- Implement repository pattern for data access
-- Add indexes for frequently queried fields
-- Use transactions for multi-document operations
-- Handle connection errors gracefully
-- Use `lean()` for read-only queries
-
-### MUST NOT DO
-
-- Access Model directly in services (use repository)
-- Skip indexes on large collections
-- Ignore transaction rollback on errors
-- Store sensitive data without encryption
-- Use `any` type for document fields
-
-## Schema Design Principles
-
-| Principle          | Description                               |
-| ------------------ | ----------------------------------------- |
-| Embed vs Reference | Embed for 1:few, reference for 1:many     |
-| Denormalization    | Duplicate data for read performance       |
-| Indexing           | Index query patterns, not just fields     |
-| Validation         | Use Mongoose validators + class-validator |
-| Timestamps         | Always enable `timestamps: true`          |
-
-## Related Powers
-
-- **NestJS Expert** - Core NestJS patterns
-- **Database Optimizer** - Query optimization
-- **Architecture Designer** - Data modeling decisions