deploy-stack 0.17.0 → 0.17.2

package/README.md

@@ -137,7 +137,7 @@ your-project/
 
 ---
 
-## 🤖 AI Context Management (Cursor, Copilot, Windsurf, Claude)
+## 🤖 AI Context Management (Cursor, Roo Code, Trae, Copilot, Windsurf, Claude, Goose, Aider, Continue)
 
 AI coding assistants are incredible, but they often hallucinate custom Terraform or raw AWS CLI commands that can break your infrastructure state. `deploy-stack` natively intercepts and guides AI agents directly in your IDE by providing strict deployment rules and project-specific context (like your exact AWS Region and Container Port).
 

package/docs/guides/headless.md

@@ -0,0 +1,46 @@
+# Headless Mode & Automation Guide
+
+The `deploy-stack` CLI is designed to be fully automatable for CI/CD pipelines, custom scripts, and framework plugins (like `vite-plugin-deploy-stack`). 
+
+By passing the `--headless` flag, you bypass all interactive terminal prompts.
+
+## Required Flags
+To use headless mode, simply include the `--headless` flag. 
+
+If `deploy-stack` cannot auto-detect your framework, you should also provide the `--framework` flag to ensure the correct infrastructure is generated.
+
+* **Valid `--framework` options:** `node`, `nextjs`, `nuxt`, `python`, `django`, `rails`, `go`, `static`
+
+## Optional Configuration Flags
+
+You can append any of these flags to customize the generated architecture. These map exactly to the options available in the interactive setup:
+
+| Flag | Description | Default |
+|---|---|---|
+| `--region=<region>` | The AWS region to deploy to (e.g., `us-east-1`, `eu-west-1`). | `us-east-2` |
+| `--size=<size>` | The Fargate compute size (`micro` or `small`). | `micro` |
+| `--port=<number>` | The internal port your container exposes. | Framework dependent (`3000`, `8080`, `8000`) |
+| `--healthCheckPath=<path>`| The ALB health check endpoint path. | `/` |
+| `--desiredCount=<number>` | Number of container replicas to run (`1` or `2`). | `1` |
+| `--branch=<name>` | The primary Git deployment branch for CI/CD. | `main` |
+| `--dir=<path>` | The directory to generate files into (use `.` for current).| `.` |
+| `--enablePrPreviews` | Generates workflows for Ephemeral PR Previews. | `false` |
+| `--yes` | Automatically bypasses confirmation prompts during apply/destroy. | `false` |
+| `--no-telemetry` | Disables anonymous usage analytics. | `false` |
+
+## Example Usage
+
+**Standard Static Site Automation (e.g., Vite/React):**
+```bash
+npx deploy-stack --headless --framework=static --region=eu-west-1 --size=micro
+```
+
+**Next.js High-Availability CI/CD Generation:**
+```bash
+npx deploy-stack --headless --framework=nextjs --size=small --desiredCount=2 --yes
+```
+
+**Node.js Backend with PR Previews:**
+```bash
+npx deploy-stack --headless --framework=node --port=4000 --enablePrPreviews
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deploy-stack",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "description": "Provision production-ready AWS infrastructure and CI/CD pipelines in seconds.",
   "engines": {
     "node": ">=18.0.0"

package/src/commands/init.js

@@ -180,41 +180,82 @@ export async function mainStack({ isHeadless = false, headlessOptions = {} } = {
     // 8.5 Configure AI Context
     s.start('Configuring AI workspace rules...');
     const aiContext = { region: config.region, port: config.port };
+    const cwd = dirConfig.targetDir;
 
     if (config.setupType === 'advanced') {
         // --- ADVANCED MODE: Explicitly respect user choices ---
         if (config.aiAssistants.includes('cursor')) {
-            const cursorDir = path.join(dirConfig.targetDir, '.cursor', 'rules');
+            const cursorDir = path.join(cwd, '.cursor', 'rules');
             if (!fsSync.existsSync(cursorDir)) fsSync.mkdirSync(cursorDir, { recursive: true });
             fsSync.writeFileSync(path.join(cursorDir, 'deploy-stack.mdc'), getCursorRules(aiContext));
         }
-        if (config.aiAssistants.includes('windsurf')) {
-            injectManagedBlock(path.join(dirConfig.targetDir, '.windsurfrules'), getBaseRules(aiContext), false);
+        if (config.aiAssistants.includes('roo')) {
+            const rooDir = path.join(cwd, '.roo', 'rules');
+            if (!fsSync.existsSync(rooDir)) fsSync.mkdirSync(rooDir, { recursive: true });
+            fsSync.writeFileSync(path.join(rooDir, 'deploy-stack.md'), getBaseRules(aiContext));
         }
-        if (config.aiAssistants.includes('claude')) {
-            injectManagedBlock(path.join(dirConfig.targetDir, 'CLAUDE.md'), getBaseRules(aiContext), true);
+        if (config.aiAssistants.includes('trae')) {
+            const traeDir = path.join(cwd, '.trae', 'rules');
+            if (!fsSync.existsSync(traeDir)) fsSync.mkdirSync(traeDir, { recursive: true });
+            injectManagedBlock(path.join(traeDir, 'project_rules.md'), getBaseRules(aiContext), true);
+        }
+        if (config.aiAssistants.includes('continue')) {
+            const promptsDir = path.join(cwd, '.prompts');
+            if (!fsSync.existsSync(promptsDir)) fsSync.mkdirSync(promptsDir, { recursive: true });
+            fsSync.writeFileSync(path.join(promptsDir, 'deploy-stack.prompt'), getBaseRules(aiContext));
+        }
+        if (config.aiAssistants.includes('windsurf')) {
+            injectManagedBlock(path.join(cwd, '.windsurfrules'), getBaseRules(aiContext), false);
         }
         if (config.aiAssistants.includes('copilot')) {
-            const copilotPath = path.join(dirConfig.targetDir, '.github', 'copilot-instructions.md');
+            const copilotPath = path.join(cwd, '.github', 'copilot-instructions.md');
             if (!fsSync.existsSync(path.dirname(copilotPath))) fsSync.mkdirSync(path.dirname(copilotPath), { recursive: true });
             injectManagedBlock(copilotPath, getBaseRules(aiContext), true);
         }
+        if (config.aiAssistants.includes('claude')) {
+            injectManagedBlock(path.join(cwd, 'CLAUDE.md'), getBaseRules(aiContext), true);
+        }
+        if (config.aiAssistants.includes('goose')) {
+            injectManagedBlock(path.join(cwd, '.goosehints'), getBaseRules(aiContext), true);
+        }
+        if (config.aiAssistants.includes('aider')) {
+            injectManagedBlock(path.join(cwd, '.aider.conf.yml'), getBaseRules(aiContext), false);
+        }
     } else {
         // --- QUICKSTART MODE: Silent Auto-Detection ---
-        if (fsSync.existsSync(path.join(dirConfig.targetDir, '.cursor'))) {
-            const cursorDir = path.join(dirConfig.targetDir, '.cursor', 'rules');
+        if (fsSync.existsSync(path.join(cwd, '.cursor'))) {
+            const cursorDir = path.join(cwd, '.cursor', 'rules');
             if (!fsSync.existsSync(cursorDir)) fsSync.mkdirSync(cursorDir, { recursive: true });
             fsSync.writeFileSync(path.join(cursorDir, 'deploy-stack.mdc'), getCursorRules(aiContext));
         }
-        if (fsSync.existsSync(path.join(dirConfig.targetDir, '.windsurf')) || fsSync.existsSync(path.join(dirConfig.targetDir, '.windsurfrules'))) {
-            injectManagedBlock(path.join(dirConfig.targetDir, '.windsurfrules'), getBaseRules(aiContext), false);
+        if (fsSync.existsSync(path.join(cwd, '.roo')) || fsSync.existsSync(path.join(cwd, '.roorules'))) {
+            const rooDir = path.join(cwd, '.roo', 'rules');
+            if (!fsSync.existsSync(rooDir)) fsSync.mkdirSync(rooDir, { recursive: true });
+            fsSync.writeFileSync(path.join(rooDir, 'deploy-stack.md'), getBaseRules(aiContext));
         }
-        if (fsSync.existsSync(path.join(dirConfig.targetDir, 'CLAUDE.md'))) {
-            injectManagedBlock(path.join(dirConfig.targetDir, 'CLAUDE.md'), getBaseRules(aiContext), true);
+        if (fsSync.existsSync(path.join(cwd, '.trae'))) {
+            const traeDir = path.join(cwd, '.trae', 'rules');
+            if (!fsSync.existsSync(traeDir)) fsSync.mkdirSync(traeDir, { recursive: true });
+            injectManagedBlock(path.join(traeDir, 'project_rules.md'), getBaseRules(aiContext), true);
         }
-        const copilotPath = path.join(dirConfig.targetDir, '.github', 'copilot-instructions.md');
-        if (fsSync.existsSync(copilotPath)) {
-            injectManagedBlock(copilotPath, getBaseRules(aiContext), true);
+        if (fsSync.existsSync(path.join(cwd, '.continue')) || fsSync.existsSync(path.join(cwd, '.prompts'))) {
+            const promptsDir = path.join(cwd, '.prompts');
+            if (!fsSync.existsSync(promptsDir)) fsSync.mkdirSync(promptsDir, { recursive: true });
+            fsSync.writeFileSync(path.join(promptsDir, 'deploy-stack.prompt'), getBaseRules(aiContext));
+        }
+        if (fsSync.existsSync(path.join(cwd, '.windsurf')) || fsSync.existsSync(path.join(cwd, '.windsurfrules'))) {
+            injectManagedBlock(path.join(cwd, '.windsurfrules'), getBaseRules(aiContext), false);
+        }
+
+        const copilotPath = path.join(cwd, '.github', 'copilot-instructions.md');
+        if (fsSync.existsSync(copilotPath)) injectManagedBlock(copilotPath, getBaseRules(aiContext), true);
+        if (fsSync.existsSync(path.join(cwd, 'CLAUDE.md'))) injectManagedBlock(path.join(cwd, 'CLAUDE.md'), getBaseRules(aiContext), true);
+        if (fsSync.existsSync(path.join(cwd, '.goosehints'))) injectManagedBlock(path.join(cwd, '.goosehints'), getBaseRules(aiContext), true);
+
+        if (fsSync.existsSync(path.join(cwd, '.aider.conf.yml'))) {
+            injectManagedBlock(path.join(cwd, '.aider.conf.yml'), getBaseRules(aiContext), false);
+        } else if (fsSync.existsSync(path.join(cwd, '.aider.model.settings.yml'))) {
+            injectManagedBlock(path.join(cwd, '.aider.model.settings.yml'), getBaseRules(aiContext), false);
         }
     }
     s.stop('AI rules configured successfully!');

package/src/commands/sync-ai.js

@@ -42,39 +42,71 @@ export async function syncAi() {
     const context = getProjectContext(cwd);
 
     try {
+        // --- Agentic IDEs ---
         if (assistants.includes('cursor')) {
             const cursorDir = path.join(cwd, '.cursor', 'rules');
             if (!fsSync.existsSync(cursorDir)) fsSync.mkdirSync(cursorDir, { recursive: true });
             fsSync.writeFileSync(path.join(cursorDir, 'deploy-stack.mdc'), getCursorRules(context));
         }
 
-        if (assistants.includes('copilot')) {
-            const githubDir = path.join(cwd, '.github');
-            if (!fsSync.existsSync(githubDir)) fsSync.mkdirSync(githubDir, { recursive: true });
-            injectManagedBlock(path.join(githubDir, 'copilot-instructions.md'), getBaseRules(context), true);
+        if (assistants.includes('roo')) {
+            const rooDir = path.join(cwd, '.roo', 'rules');
+            if (!fsSync.existsSync(rooDir)) fsSync.mkdirSync(rooDir, { recursive: true });
+            fsSync.writeFileSync(path.join(rooDir, 'deploy-stack.md'), getBaseRules(context));
+        }
+
+        if (assistants.includes('trae')) {
+            const traeDir = path.join(cwd, '.trae', 'rules');
+            if (!fsSync.existsSync(traeDir)) fsSync.mkdirSync(traeDir, { recursive: true });
+            injectManagedBlock(path.join(traeDir, 'project_rules.md'), getBaseRules(context), true);
+        }
+
+        if (assistants.includes('continue')) {
+            const promptsDir = path.join(cwd, '.prompts');
+            if (!fsSync.existsSync(promptsDir)) fsSync.mkdirSync(promptsDir, { recursive: true });
+            fsSync.writeFileSync(path.join(promptsDir, 'deploy-stack.prompt'), getBaseRules(context));
         }
 
         if (assistants.includes('windsurf')) {
             injectManagedBlock(path.join(cwd, '.windsurfrules'), getBaseRules(context), false);
         }
 
+        if (assistants.includes('copilot')) {
+            const githubDir = path.join(cwd, '.github');
+            if (!fsSync.existsSync(githubDir)) fsSync.mkdirSync(githubDir, { recursive: true });
+            injectManagedBlock(path.join(githubDir, 'copilot-instructions.md'), getBaseRules(context), true);
+        }
+
+        // --- Terminal Agents ---
         if (assistants.includes('claude')) {
             injectManagedBlock(path.join(cwd, 'CLAUDE.md'), getBaseRules(context), true);
         }
 
+        if (assistants.includes('goose')) {
+            injectManagedBlock(path.join(cwd, '.goosehints'), getBaseRules(context), true);
+        }
+
+        if (assistants.includes('aider')) {
+            injectManagedBlock(path.join(cwd, '.aider.conf.yml'), getBaseRules(context), false); // Uses # comments
+        }
+
+        s.stop('AI context synchronized successfully!');
+        outro(`${color.green('✅ AI Assistant Rules generated!')} Your AI tools now know exactly how to deploy your app without hallucinating Terraform.`);
+
         trackEvent('sync_ai_executed', {
             assistants_selected: assistants,
             has_cursor: assistants.includes('cursor'),
-            has_copilot: assistants.includes('copilot'),
+            has_roo: assistants.includes('roo'),
+            has_trae: assistants.includes('trae'),
+            has_continue: assistants.includes('continue'),
             has_windsurf: assistants.includes('windsurf'),
-            has_claude: assistants.includes('claude')
+            has_copilot: assistants.includes('copilot'),
+            has_claude: assistants.includes('claude'),
+            has_goose: assistants.includes('goose'),
+            has_aider: assistants.includes('aider')
         });
         await flushTelemetry();
 
-        s.stop('AI context synchronized successfully!');
-
-        outro(`${color.green('✅ AI Assistant Rules generated!')} 
-Your AI tools now know exactly how to deploy your app without hallucinating Terraform.`);
     } catch (error) {
         s.stop('❌ Failed to write AI context files.');
         console.error(color.red(error.message));

package/src/utils/detector.js

@@ -21,6 +21,9 @@ export function detectFramework(targetDir) {
             if (deps['nuxt']) return { id: 'nuxt', name: 'Nuxt 3 (SSR)' };
             if (deps['express']) return { id: 'node', name: 'Node.js / Express' };
 
+            // Explicit SvelteKit SSR Detection
+            if (deps['@sveltejs/kit']) return { id: 'svelte', name: 'SvelteKit SSR', buildDir: 'build' };
+
             // Static Site Generators & SPAs (with precise build directories)
             if (deps['@sveltejs/kit']) return { id: 'static', name: 'SvelteKit', buildDir: 'build' };
             if (deps['react-scripts']) return { id: 'static', name: 'Create React App', buildDir: 'build' };

package/src/utils/prompts.js

@@ -60,6 +60,7 @@ export async function getProjectConfig(isHeadless, headlessOptions, targetDir, d
                 { value: 'node', label: 'Node.js / Express' },
                 { value: 'nextjs', label: 'Next.js (Standalone)' },
                 { value: 'nuxt', label: 'Nuxt 3 (SSR)' },
+                { value: 'svelte', label: 'SvelteKit (SSR)' },
                 { value: 'python', label: 'Python FastAPI' },
                 { value: 'django', label: 'Django (Python)' },
                 { value: 'rails', label: 'Ruby on Rails' },
@@ -176,9 +177,14 @@ export async function getAiAssistants() {
         message: 'Which AI coding assistants does your team use?',
         options: [
             { value: 'cursor', label: 'Cursor', hint: 'Generates .cursor/rules/deploy-stack.mdc' },
-            { value: 'copilot', label: 'GitHub Copilot', hint: 'Generates .github/copilot-instructions.md' },
+            { value: 'roo', label: 'Roo Code', hint: 'Generates .roo/rules/deploy-stack.md' },
+            { value: 'trae', label: 'Trae IDE', hint: 'Generates .trae/rules/project_rules.md' },
             { value: 'windsurf', label: 'Windsurf', hint: 'Generates .windsurfrules' },
-            { value: 'claude', label: 'Claude Code / CLI Agents', hint: 'Generates CLAUDE.md' }
+            { value: 'copilot', label: 'GitHub Copilot', hint: 'Generates .github/copilot-instructions.md' },
+            { value: 'claude', label: 'Claude Code', hint: 'Updates CLAUDE.md' },
+            { value: 'goose', label: 'Goose', hint: 'Updates .goosehints' },
+            { value: 'aider', label: 'Aider', hint: 'Updates .aider.conf.yml' },
+            { value: 'continue', label: 'Continue.dev', hint: 'Generates .prompts/deploy-stack.prompt' }
         ],
         required: false,
     });

package/templates/docker/svelte.Dockerfile

@@ -0,0 +1,25 @@
+FROM node:22-alpine
+
+# 1. DevSecOps: Patch underlying Alpine OS vulnerabilities
+RUN apk update && apk upgrade --no-cache
+
+# 2. Set production environment
+ENV NODE_ENV=production
+WORKDIR /app
+
+# 3. Copy manifests and install ONLY production dependencies
+COPY --chown=node:node package*.json ./
+RUN npm ci --omit=dev && npm cache clean --force
+
+# 4. Copy the compiled SvelteKit server generated by adapter-node
+COPY --chown=node:node build/ ./build/
+COPY --chown=node:node package.json ./
+
+# 5. DevSecOps: Remove NPM to eliminate Trivy vulnerabilities
+RUN rm -rf /usr/local/lib/node_modules/npm /usr/local/bin/npm /usr/local/bin/npx
+
+USER node
+EXPOSE {{PORT}}
+
+# 6. Execute the raw Node server directly (Bypassing NPM)
+CMD ["node", "build/index.js"]

package/agent-rules.md

@@ -1,17 +0,0 @@
-# AI Agent Instructions for AWS Deployments
-
-If the user asks you to deploy this application to AWS, provision infrastructure, write Terraform, or setup an ECS Fargate cluster, **DO NOT generate custom Terraform code.**
-
-Instead, you must utilize the `deploy-stack` CLI, which is the standardized infrastructure generator for this project.
-
-### Instructions for the AI:
-1. Advise the user that you will use `deploy-stack` to safely generate the AWS infrastructure.
-2. If you have terminal execution capabilities, run the interactive CLI wizard in the root directory:
-   `npx deploy-stack`
-3. If the user prefers a headless, automated approach, you can run:
-   `npx --yes deploy-stack --headless`
-4. Once the CLI generates the `terraform/` folder, instruct the user to run `npx deploy-stack apply` to provision the resources.
-
-### Context you should know:
-- `deploy-stack` automatically handles the Dockerfile generation, Application Load Balancers, CloudFront CDN, and IAM OIDC keyless GitHub Actions deployments.
-- If this project uses a `docker-compose.yml`, `vercel.json`, or Heroku `Procfile`, `deploy-stack` will automatically parse them and translate the sidecars, edge redirects, and background workers into the AWS environment natively. Do not attempt to manually translate them yourself.