changes for deploy

Author: motm32

package-lock.json

@@ -27,7 +27,9 @@
         "multi-root ready"
     ],
     "preview": true,
-    "activationEvents": [],
+    "activationEvents": [
+        "onCommand:azureProjectCreation.openDeployPlan"
+    ],
     "main": "./main.js",
     "contributes": {
         "mcpServerDefinitionProviders": [
@@ -122,7 +124,7 @@
             },
             {
                 "command": "containerApps.showProjectCreation",
-                "title": "Show Azure Project Creation View",
+                "title": "Open Deploy Plan View",
                 "category": "Azure Container Apps"
             },
             {
@@ -893,6 +895,7 @@
         "deep-eql": "^4.1.3",
         "dotenv": "^16.0.0",
         "fs-extra": "^8.1.0",
+        "mermaid": "^11.14.0",
         "monaco-editor": "~0.51.0",
         "p-retry": "^4.6.2",
         "react": "^18.3.1",

package.json

@@ -3,73 +3,72 @@
  *  Licensed under the MIT License. See License.md in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import * as vscode from "vscode";
 import { type DeploymentPlanData } from "../../webviews/DeploymentPlanView";
 import { DeploymentPlanViewController } from "../../webviews/DeploymentPlanViewController";
-import * as vscode from "vscode";
+import { parseDeploymentPlanMarkdown } from "../../utils/parseDeploymentPlanMarkdown";
 
 let currentDeploymentPlanViewController: DeploymentPlanViewController | undefined;
 
-const sampleDeploymentPlanData: DeploymentPlanData = {
-    status: "Awaiting Approval",
-    mode: "MODERNIZE — deploy existing full-stack app to Azure",
-    subscription: "meganmott dev",
-    location: "East US",
-    locationCode: "eastus",
-    mermaidDiagram: `graph TD
-    Browser -->|HTTPS| SWA[Azure Static Web Apps<br/>React / Vite frontend]
-    SWA -->|/api/* proxy| FN[Azure Functions App<br/>Node.js 20 · TypeScript]
-    FN -->|Managed Identity| KV[Azure Key Vault<br/>Cosmos connection string]
-    FN -->|Cosmos SDK| DB[(Azure Cosmos DB<br/>NoSQL · Serverless)]
+export function openDeploymentPlanView(uri: vscode.Uri): void {
+    void openDeploymentPlanViewAsync(uri);
+}
+
+export function openDeploymentPlanViewWithContent(content: string): void {
+    const planData = parseDeploymentPlanMarkdown(content);
+    showOrUpdateView(planData);
+}
+
+export function refreshDeploymentPlanView(uri: vscode.Uri): void {
+    if (currentDeploymentPlanViewController) {
+        void refreshDeploymentPlanViewAsync(uri);
+    }
+}
 
-    style SWA fill:#0078d4,color:#fff
-    style FN fill:#0078d4,color:#fff
-    style KV fill:#0078d4,color:#fff
-    style DB fill:#0078d4,color:#fff`,
-    workspaceScan: {
-        headers: ["Component", "Technology", "Azure Target"],
-        rows: [
-            ["src/web", "React 18, Vite, TypeScript", "Azure Static Web Apps"],
-            ["src/functions", "Azure Functions v4, Node.js, TypeScript", "Azure Functions (linked to SWA)"],
-            ["src/shared", "TypeScript library", "Built + bundled (no separate service)"],
-            ["Cosmos DB", "@azure/cosmos SDK, connection string env var", "Azure Cosmos DB for NoSQL (serverless)"],
-            ["Web → API routing", "Vite /api proxy in dev", "SWA native /api proxy at runtime"],
-        ],
-    },
-    decisions: {
-        headers: ["Decision", "Choice", "Rationale"],
-        rows: [
-            ["Recipe", "AZD + Bicep", "Both tools installed; AZD is the recommended default for end-to-end deploy"],
-            ["Functions plan", "Consumption", "Cost-efficient for low-to-medium workloads"],
-            ["Cosmos DB capacity", "Serverless", "No sustained throughput; ideal for dev/compliance calendar usage"],
-            ["Frontend hosting", "Azure Static Web Apps (SWA)", "Native Vite/React support; built-in /api proxy to linked Functions app"],
-            ["Secrets", "Key Vault + SWA/Functions app settings", "Cosmos connection string stored in Key Vault; referenced via @Microsoft.KeyVault(...)"],
-            ["Identity", "System-assigned Managed Identity on Functions app", "Grants Functions access to Key Vault without storing credentials in config"],
-        ],
-    },
-    resources: {
-        headers: ["Resource", "Name pattern", "SKU / Tier"],
-        rows: [
-            ["Resource Group", "rg-compliance-<env>", "—"],
-            ["Static Web Apps", "swa-compliance-<env>", "Free"],
-            ["Functions App", "func-compliance-<env>", "Consumption (Y1)"],
-            ["App Service Plan", "asp-compliance-<env>", "[Consumption — auto-created by Functions]"],
-            ["Storage Account", "stcompliance<env>", "Standard LRS (required by Functions)"],
-            ["Cosmos DB account", "cosmos-compliance-<env>", "Serverless, NoSQL"],
-            ["Key Vault", "kv-compliance-<env>", "Standard"],
-            ["Log Analytics Workspace", "log-compliance-<env>", "PerGB2018"],
-            ["Application Insights", "appi-compliance-<env>", "—"],
-        ],
-    },
-};
+export async function openDeploymentPlanViewFromWorkspace(): Promise<void> {
+    const files = await vscode.workspace.findFiles('**/.azure/plan.md', '**/node_modules/**', 10);
+    if (files.length === 0) {
+        void vscode.window.showInformationMessage('No deployment plan markdown files found in the workspace.');
+        return;
+    }
+
+    let selected: vscode.Uri;
+    if (files.length === 1) {
+        selected = files[0];
+    } else {
+        const picked = await vscode.window.showQuickPick(
+            files.map((f) => ({ label: vscode.workspace.asRelativePath(f), uri: f })),
+            { placeHolder: 'Select a deployment plan file to open' },
+        );
+        if (!picked) {
+            return;
+        }
+        selected = picked.uri;
+    }
+
+    await openDeploymentPlanViewAsync(selected);
+}
+
+async function openDeploymentPlanViewAsync(uri: vscode.Uri): Promise<void> {
+    const content = Buffer.from(await vscode.workspace.fs.readFile(uri)).toString('utf-8');
+    const planData = parseDeploymentPlanMarkdown(content);
+    showOrUpdateView(planData);
+}
+
+async function refreshDeploymentPlanViewAsync(uri: vscode.Uri): Promise<void> {
+    const content = Buffer.from(await vscode.workspace.fs.readFile(uri)).toString('utf-8');
+    const planData = parseDeploymentPlanMarkdown(content);
+    currentDeploymentPlanViewController?.updateDeploymentPlanData(planData);
+}
 
-export function openDeploymentPlanView(): void {
+function showOrUpdateView(planData: DeploymentPlanData): void {
     if (currentDeploymentPlanViewController) {
-        currentDeploymentPlanViewController.updateDeploymentPlanData(sampleDeploymentPlanData);
+        currentDeploymentPlanViewController.updateDeploymentPlanData(planData);
         currentDeploymentPlanViewController.revealToForeground(vscode.ViewColumn.Active);
         return;
     }
 
-    currentDeploymentPlanViewController = new DeploymentPlanViewController(sampleDeploymentPlanData);
+    currentDeploymentPlanViewController = new DeploymentPlanViewController(planData);
     currentDeploymentPlanViewController.revealToForeground(vscode.ViewColumn.Active);
 
     currentDeploymentPlanViewController.panel.onDidDispose(() => {

src/commands/copilot/openDeploymentPlanView.ts

@@ -12,6 +12,7 @@ import { deployWithCopilot } from './copilot/deployWithCopilot';
 import { createProjectWithCopilot } from './copilot/createProjectWithCopilot';
 import { openPlanView, openPlanViewFromWorkspace } from './copilot/openPlanView';
 import { openLocalPlanView, openLocalPlanViewFromWorkspace } from './copilot/openLocalPlanView';
+import { openDeploymentPlanView, openDeploymentPlanViewFromWorkspace } from './copilot/openDeploymentPlanView';
 import { createContainerApp } from './createContainerApp/createContainerApp';
 import { createManagedEnvironment } from './createManagedEnvironment/createManagedEnvironment';
 import { deleteContainerApp } from './deleteContainerApp/deleteContainerApp';
@@ -151,9 +152,14 @@ export function registerCommands(): void {
     registerCommand('containerApps.openPlanViewFromWorkspace', () => openPlanViewFromWorkspace());
     registerCommand('containerApps.openLocalPlanView', (_context: IActionContext, uri: vscode.Uri) => openLocalPlanView(uri));
     registerCommand('containerApps.openLocalPlanViewFromWorkspace', () => openLocalPlanViewFromWorkspace());
-    registerCommand('containerApps.showProjectCreation', async () => {
-        await vscode.commands.executeCommand('azureProjectCreation.show');
+    registerCommand('azureProjectCreation.openDeployPlan', (_context: IActionContext, uri?: vscode.Uri) => {
+        if (uri) {
+            openDeploymentPlanView(uri);
+        } else {
+            void openDeploymentPlanViewFromWorkspace();
+        }
     });
+    registerCommand('containerApps.showProjectCreation', () => openDeploymentPlanViewFromWorkspace());
     registerCommand('containerApps.startLocalDev', async () => {
         await vscode.commands.executeCommand('workbench.action.chat.open', {
             mode: 'agent',

src/commands/registerCommands.ts

@@ -13,6 +13,7 @@ import * as path from 'path';
 import { v4 as uuid } from 'uuid';
 import * as vscode from 'vscode';
 import { createContainerAppsApiProvider } from './commands/api/createContainerAppsApiProvider';
+import { openDeploymentPlanView, refreshDeploymentPlanView } from './commands/copilot/openDeploymentPlanView';
 import { openLocalPlanView, refreshLocalPlanView } from './commands/copilot/openLocalPlanView';
 import { openPlanView, refreshPlanView } from './commands/copilot/openPlanView';
 import { registerCommands } from './commands/registerCommands';
@@ -92,6 +93,26 @@ export async function activate(context: vscode.ExtensionContext, perfStats: { lo
         });
         context.subscriptions.push(localPlanWatcher);
 
+        // Watch for .azure/plan.md creation to open the deployment plan view
+        const deploymentPlanWatcher = vscode.workspace.createFileSystemWatcher('**/.azure/plan.md');
+        let deploymentPlanViewDebounceTimer: ReturnType<typeof setTimeout> | undefined;
+        const debounceDeploymentPlanViewOpen = (uri: vscode.Uri) => {
+            if (deploymentPlanViewDebounceTimer) { clearTimeout(deploymentPlanViewDebounceTimer); }
+            deploymentPlanViewDebounceTimer = setTimeout(() => {
+                deploymentPlanViewDebounceTimer = undefined;
+                openDeploymentPlanView(uri);
+            }, 2000);
+        };
+        deploymentPlanWatcher.onDidCreate((uri) => debounceDeploymentPlanViewOpen(uri));
+        deploymentPlanWatcher.onDidChange((uri) => {
+            if (deploymentPlanViewDebounceTimer) {
+                debounceDeploymentPlanViewOpen(uri);
+            } else {
+                refreshDeploymentPlanView(uri);
+            }
+        });
+        context.subscriptions.push(deploymentPlanWatcher);
+
         // Fallback: detect plan files via workspace file creation events
         // (fires when files are created via VS Code API, e.g. WorkspaceEdit / Copilot tools)
         context.subscriptions.push(
@@ -102,11 +123,27 @@ export async function activate(context: vscode.ExtensionContext, perfStats: { lo
                         debouncePlanViewOpen(file);
                     } else if (filename === 'local-dev.plan.md') {
                         debounceLocalPlanViewOpen(file);
+                    } else if (filename === 'plan.md' && file.path.includes('.azure/')) {
+                        debounceDeploymentPlanViewOpen(file);
                     }
                 }
             }),
         );
 
+        // Fallback: detect .azure/plan.md creation and changes for dot-directory watcher reliability
+        context.subscriptions.push(
+            vscode.workspace.onDidSaveTextDocument((doc) => {
+                if (doc.fileName.replace(/\\/g, '/').includes('.azure/plan.md')) {
+                    refreshDeploymentPlanView(doc.uri);
+                }
+            }),
+            vscode.workspace.onDidOpenTextDocument((doc) => {
+                if (doc.fileName.replace(/\\/g, '/').includes('.azure/plan.md')) {
+                    debounceDeploymentPlanViewOpen(doc.uri);
+                }
+            }),
+        );
+
         // Register MCP server for scaffold-complete UI in chat
         context.subscriptions.push(
             vscode.lm.registerMcpServerDefinitionProvider('containerAppsMcp', {