npm - sdlc-agent-4-enterprise-server - Versions diffs - 1.0.0 - Mend

sdlc-agent-4-enterprise-server 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1434) hide show

package/extension/src/panels/security-panel.ts ADDED Viewed

@@ -0,0 +1,162 @@
+/**
+ * SecurityPanel — KSA-173
+ * Displays security findings grouped by severity with file links and remediation suggestions.
+ * Calls MCP tools: code_search (kind=security_finding), mem_search (type=ERROR_PATTERN).
+ */
+import * as vscode from "vscode";
+import { WebviewToExtMessage } from "../types";
+import { McpServerManager } from "../mcp-server-manager";
+import { BasePanel } from "./base-panel";
+interface SecurityFinding {
+  id: string;
+  severity: "critical" | "high" | "medium" | "low";
+  title: string;
+  file: string;
+  line: number;
+  description: string;
+  remediation: string;
+}
+export class SecurityPanel extends BasePanel {
+  constructor(mcpManager: McpServerManager, extensionUri: vscode.Uri) {
+    super("quality", mcpManager, extensionUri);
+  }
+  get viewType(): string {
+    return "kiroSecurityPanel";
+  }
+  protected create(column: vscode.ViewColumn = vscode.ViewColumn.One): void {
+    this._panel = vscode.window.createWebviewPanel(
+      "kiroSecurityPanel",
+      "Security Findings",
+      column,
+      { enableScripts: true, retainContextWhenHidden: true }
+    );
+    this._panel.webview.html = this.getHtml(this._panel.webview);
+    this._panel.webview.onDidReceiveMessage((msg: WebviewToExtMessage) => this.handleMessage(msg));
+    this._panel.onDidDispose(() => { this._panel = undefined; });
+  }
+  getHtml(_webview: vscode.Webview): string {
+    const nonce = this.getNonce();
+    return `<!DOCTYPE html>
+<html lang="en"><head><meta charset="UTF-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'nonce-${nonce}';">
+<style>
+body{font-family:var(--vscode-font-family);padding:16px;color:var(--vscode-foreground);background:var(--vscode-editor-background)}
+.severity-group{margin-bottom:16px}.severity-header{font-weight:bold;padding:4px 8px;border-radius:3px;margin-bottom:8px}
+.critical{background:#dc2626;color:#fff}.high{background:#ea580c;color:#fff}.medium{background:#ca8a04;color:#fff}.low{background:#2563eb;color:#fff}
+.finding{padding:8px;margin:4px 0;border:1px solid var(--vscode-editorWidget-border);border-radius:3px;cursor:pointer}
+.finding:hover{background:var(--vscode-list-hoverBackground)}.finding-title{font-weight:600}
+.finding-file{font-size:.85em;opacity:.8}.remediation{font-size:.85em;color:var(--vscode-descriptionForeground);margin-top:4px}
+.loading{text-align:center;padding:40px;opacity:.7}#summary{display:flex;gap:12px;margin-bottom:16px}
+.badge{padding:2px 8px;border-radius:10px;font-size:.85em}
+</style></head><body>
+<h2>Security Findings</h2><div id="summary"></div>
+<div id="loading" class="loading">Scanning for security issues...</div><div id="findings"></div>
+<script nonce="${nonce}">
+const vscode=acquireVsCodeApi();vscode.postMessage({type:'ready'});
+window.addEventListener('message',e=>{const msg=e.data;if(msg.type==='securityData')renderFindings(msg.findings);});
+function renderFindings(findings){document.getElementById('loading').style.display='none';
+const groups={critical:[],high:[],medium:[],low:[]};
+findings.forEach(f=>{if(groups[f.severity])groups[f.severity].push(f);});
+let s='',h='';for(const[sev,items]of Object.entries(groups)){if(!items.length)continue;
+s+='<span class="badge '+sev+'">'+sev.toUpperCase()+': '+items.length+'</span>';
+h+='<div class="severity-group"><div class="severity-header '+sev+'">'+sev.toUpperCase()+' ('+items.length+')</div>';
+items.forEach(f=>{h+='<div class="finding" data-file="'+f.file+'" data-line="'+f.line+'">';
+h+='<div class="finding-title">'+f.title+'</div><div class="finding-file">'+f.file+':'+f.line+'</div>';
+h+='<div class="remediation">'+f.remediation+'</div></div>';});h+='</div>';}
+document.getElementById('summary').innerHTML=s||'<span>No findings</span>';
+document.getElementById('findings').innerHTML=h||'<p>No security issues found.</p>';
+document.querySelectorAll('.finding').forEach(el=>{el.addEventListener('click',()=>{
+vscode.postMessage({type:'openFile',file:el.dataset.file,line:parseInt(el.dataset.line)});});});}
+</script></body></html>`;
+  }
+  async loadData(): Promise<void> {
+    try {
+      const findings = await this.fetchFindings();
+      this.sendMessage({ type: "securityData", findings } as any);
+    } catch (err) {
+      this.sendMessage({ type: "error", message: `Security scan failed: ${(err as Error).message}`, retryable: true });
+    }
+  }
+  async handleMessage(msg: WebviewToExtMessage): Promise<void> {
+    switch (msg.type) {
+      case "ready":
+      case "refresh":
+        await this.loadData();
+        break;
+      case "manualRetry":
+        try { await this.mcpManager.reconnect(); } catch { /* ignore */ }
+        break;
+      default:
+        await this.handleOpenFile(msg as any);
+        break;
+    }
+  }
+  private async handleOpenFile(msg: { type: string; file?: string; line?: number }): Promise<void> {
+    if (msg.type !== "openFile" || !msg.file) { return; }
+    try {
+      const doc = await vscode.workspace.openTextDocument(msg.file);
+      const editor = await vscode.window.showTextDocument(doc);
+      const pos = new vscode.Position(Math.max(0, (msg.line || 1) - 1), 0);
+      editor.selection = new vscode.Selection(pos, pos);
+      editor.revealRange(new vscode.Range(pos, pos), vscode.TextEditorRevealType.InCenter);
+    } catch { /* file may not exist */ }
+  }
+  private async fetchFindings(): Promise<SecurityFinding[]> {
+    const findings: SecurityFinding[] = [];
+    try {
+      const raw = await this.mcpManager.invokeTool("code_search", { query: "security vulnerability", limit: 50 });
+      const parsed = JSON.parse(raw);
+      const items = Array.isArray(parsed) ? parsed : (parsed.results || []);
+      for (const item of items) {
+        findings.push({
+          id: String(item.id || findings.length),
+          severity: toSeverity(item.severity || item.kind),
+          title: item.name || item.title || "Security Issue",
+          file: item.file || item.path || "",
+          line: item.line || 1,
+          description: item.description || item.content || "",
+          remediation: item.remediation || item.suggestion || "Review and fix this issue.",
+        });
+      }
+    } catch { /* MCP tool may not be available */ }
+    try {
+      const raw = await this.mcpManager.invokeTool("mem_search", { query: "security", type: "ERROR_PATTERN", limit: 20 });
+      const parsed = JSON.parse(raw);
+      const items = Array.isArray(parsed) ? parsed : (parsed.results || []);
+      for (const item of items) {
+        findings.push({
+          id: String(item.id || findings.length),
+          severity: "medium",
+          title: item.title || item.summary || "Error Pattern",
+          file: item.source || "",
+          line: 1,
+          description: item.content || "",
+          remediation: item.suggestion || "Review error pattern for security implications.",
+        });
+      }
+    } catch { /* ignore */ }
+    return findings;
+  }
+}
+function toSeverity(value: string | undefined): SecurityFinding["severity"] {
+  if (!value) { return "medium"; }
+  const v = value.toLowerCase();
+  if (v.includes("critical")) { return "critical"; }
+  if (v.includes("high")) { return "high"; }
+  if (v.includes("low") || v.includes("info")) { return "low"; }
+  return "medium";
+}

package/extension/src/panels/settings/SettingsMessageHandler.ts ADDED Viewed

@@ -0,0 +1,190 @@
+/**
+ * SettingsMessageHandler — handles all webview messages for the Settings panel.
+ * Extracted from SettingsPanel for SRP.
+ */
+import * as vscode from "vscode";
+import { SECRET_KEYS } from "../../models";
+import { LlmTestService } from "../../services/LlmTestService";
+import { ProviderConfigService } from "../../services/ProviderConfigService";
+export class SettingsMessageHandler {
+  private readonly llmTestService: LlmTestService;
+  private readonly configService: ProviderConfigService;
+  constructor(
+    private readonly secrets: vscode.SecretStorage,
+    private readonly postMessage: (msg: any) => void
+  ) {
+    this.llmTestService = new LlmTestService(secrets);
+    this.configService = new ProviderConfigService(secrets);
+  }
+  async handle(msg: any): Promise<void> {
+    switch (msg.type) {
+      case "ready":
+      case "getState":
+        await this.sendCurrentState();
+        break;
+      case "setProvider":
+        await this.configService.updateConfig("llmProvider", msg.provider);
+        await this.sendCurrentState();
+        await this.handleAutoTest(msg.provider);
+        break;
+      case "getModels":
+        await this.handleGetModels(msg.provider);
+        break;
+      case "setModel":
+        await this.configService.updateConfig("llmModel", msg.model);
+        break;
+      case "setOllamaUrl":
+        await this.configService.updateConfig("ollamaUrl", msg.url);
+        break;
+      case "setBaseUrl":
+        await this.handleSetBaseUrl(msg.provider, msg.url);
+        break;
+      case "saveApiKey":
+        await this.handleSaveApiKey(msg.provider, msg.key);
+        break;
+      case "clearApiKey":
+        await this.handleClearApiKey(msg.provider);
+        break;
+      case "testOllamaConnection":
+        await this.handleTestOllama(msg.url);
+        break;
+      case "testLlm":
+      case "testLlmConnection":
+        await this.handleTestLlm(msg.provider, msg.baseUrl);
+        break;
+      case "setBackendUrl":
+        await this.handleSetBackendUrl(msg.url);
+        break;
+      case "testBackendConnection":
+        await this.handleTestBackend(msg.url);
+        break;
+      case "setMcpServerPort":
+        await this.handleSetMcpPort(msg.port);
+        break;
+      case "setEnableMcpServer":
+        await this.handleSetEnableMcp(msg.enabled);
+        break;
+      case "restartMcpServer":
+        await this.handleRestartMcpServer();
+        break;
+    }
+  }
+  private async sendCurrentState(): Promise<void> {
+    const state = await this.configService.getCurrentState();
+    this.postMessage({ type: "state", ...state });
+    const { models, selected, defaultModel } = await this.configService.getModels(state.provider, state.model);
+    this.postMessage({ type: "models", provider: state.provider, models, selected, defaultModel });
+  }
+  private async handleGetModels(provider: string): Promise<void> {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    const currentModel = config.get<string>("llmModel", "");
+    const { models, selected, defaultModel } = await this.configService.getModels(provider, currentModel);
+    this.postMessage({ type: "models", provider, models, selected, defaultModel });
+  }
+  private async handleSetBaseUrl(provider: string, url: string): Promise<void> {
+    const keyMap: Record<string, string> = {
+      anthropic: "anthropicBaseUrl",
+      openai: "openaiBaseUrl",
+      lmstudio: "lmstudioBaseUrl",
+      openrouter: "openrouterBaseUrl",
+    };
+    const key = keyMap[provider];
+    if (key) { await this.configService.updateConfig(key, url); }
+  }
+  private async handleSaveApiKey(provider: string, key: string): Promise<void> {
+    const secretKey = SECRET_KEYS[provider];
+    if (!secretKey) {
+      this.postMessage({ type: "keySaved", provider, success: false, error: "Unknown provider" });
+      return;
+    }
+    try {
+      await this.secrets.store(secretKey, key);
+      this.postMessage({ type: "keySaved", provider, success: true });
+    } catch (err: any) {
+      this.postMessage({ type: "keySaved", provider, success: false, error: err.message });
+    }
+  }
+  private async handleClearApiKey(provider: string): Promise<void> {
+    const secretKey = SECRET_KEYS[provider];
+    if (!secretKey) { return; }
+    await this.secrets.delete(secretKey);
+    this.postMessage({ type: "keyCleared", provider });
+  }
+  private async handleTestOllama(url: string): Promise<void> {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const response = await fetch(`${url}/api/tags`, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (response.ok) {
+        this.postMessage({ type: "ollamaTested", success: true });
+      } else {
+        this.postMessage({ type: "ollamaTested", success: false, error: `HTTP ${response.status}` });
+      }
+    } catch (err: any) {
+      this.postMessage({ type: "ollamaTested", success: false, error: err.message });
+    }
+  }
+  private async handleTestLlm(provider?: string, baseUrl?: string): Promise<void> {
+    const result = await this.llmTestService.testLlm(provider, baseUrl);
+    this.postMessage({ type: "llmTestResult", ...result });
+  }
+  private async handleAutoTest(provider: string): Promise<void> {
+    const result = await this.llmTestService.autoTestAndNotify(provider);
+    this.postMessage({ type: "llmTestResult", ...result });
+  }
+  private async handleSetBackendUrl(url: string): Promise<void> {
+    await vscode.workspace.getConfiguration("kiroSdlc")
+      .update("backend.url", url, vscode.ConfigurationTarget.Workspace);
+  }
+  private async handleTestBackend(url: string): Promise<void> {
+    try {
+      const start = Date.now();
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const response = await fetch(`${url}/health`, { signal: controller.signal });
+      clearTimeout(timeout);
+      const latencyMs = Date.now() - start;
+      if (response.ok) {
+        this.postMessage({ type: "backendTestResult", success: true, message: "Connected", latencyMs });
+      } else {
+        this.postMessage({ type: "backendTestResult", success: false, message: `HTTP ${response.status}`, latencyMs });
+      }
+    } catch (err: any) {
+      this.postMessage({ type: "backendTestResult", success: false, message: err.message });
+    }
+  }
+  private async handleSetMcpPort(port: number): Promise<void> {
+    await vscode.workspace.getConfiguration("kiroSdlc")
+      .update("mcpServerPort", port, vscode.ConfigurationTarget.Workspace);
+  }
+  private async handleSetEnableMcp(enabled: boolean): Promise<void> {
+    await vscode.workspace.getConfiguration("kiroSdlc")
+      .update("enableMcpServer", enabled, vscode.ConfigurationTarget.Workspace);
+  }
+  private async handleRestartMcpServer(): Promise<void> {
+    try {
+      await vscode.commands.executeCommand("kiroSdlc.restartMcpServer");
+      this.postMessage({ type: "mcpServerRestarted", success: true, message: "MCP wrapper server restarted successfully." });
+    } catch (err: any) {
+      this.postMessage({ type: "mcpServerRestarted", success: false, message: `Restart failed: ${err.message}` });
+    }
+  }
+}

package/extension/src/panels/settings/SettingsPanel.ts ADDED Viewed

@@ -0,0 +1,121 @@
+/**
+ * SettingsPanel — WebviewPanel creation and message routing.
+ * Thin shell that delegates business logic to SettingsMessageHandler.
+ */
+import * as vscode from "vscode";
+import { getNonce } from "../../mcp-server-manager";
+import { SettingsMessageHandler } from "./SettingsMessageHandler";
+export class SettingsPanel {
+  public static readonly viewType = "kiroSettingsPanel";
+  public static instance: SettingsPanel | undefined;
+  private readonly panel: vscode.WebviewPanel;
+  private readonly messageHandler: SettingsMessageHandler;
+  private disposables: vscode.Disposable[] = [];
+  private constructor(
+    private readonly extensionUri: vscode.Uri,
+    private readonly secrets: vscode.SecretStorage
+  ) {
+    this.panel = vscode.window.createWebviewPanel(
+      SettingsPanel.viewType,
+      "SDLC Pipeline Settings",
+      vscode.ViewColumn.One,
+      {
+        enableScripts: true,
+        retainContextWhenHidden: true,
+        localResourceRoots: [
+          vscode.Uri.joinPath(this.extensionUri, "webview-assets"),
+        ],
+      }
+    );
+    this.panel.iconPath = new vscode.ThemeIcon("gear");
+    this.panel.webview.html = this.getHtml(this.panel.webview);
+    this.messageHandler = new SettingsMessageHandler(
+      this.secrets,
+      (msg) => this.panel.webview.postMessage(msg)
+    );
+    this.panel.webview.onDidReceiveMessage(
+      (msg) => this.messageHandler.handle(msg),
+      undefined,
+      this.disposables
+    );
+    this.panel.onDidDispose(
+      () => {
+        SettingsPanel.instance = undefined;
+        this.disposeInternal();
+      },
+      null,
+      this.disposables
+    );
+  }
+  /** Open or reveal the settings panel (singleton). */
+  public static open(extensionUri: vscode.Uri, secrets: vscode.SecretStorage): void {
+    if (SettingsPanel.instance) {
+      SettingsPanel.instance.panel.reveal();
+      return;
+    }
+    SettingsPanel.instance = new SettingsPanel(extensionUri, secrets);
+  }
+  public dispose(): void {
+    this.panel.dispose();
+  }
+  private disposeInternal(): void {
+    this.disposables.forEach(d => d.dispose());
+    this.disposables = [];
+  }
+  private getHtml(webview: vscode.Webview): string {
+    const nonce = getNonce();
+    const cspSource = webview.cspSource;
+    const cssUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this.extensionUri, "webview-assets", "settings", "settings.css")
+    );
+    const jsUri = webview.asWebviewUri(
+      vscode.Uri.joinPath(this.extensionUri, "webview-assets", "settings", "settings.js")
+    );
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}'; style-src ${cspSource} 'unsafe-inline'; img-src ${cspSource} data:; font-src ${cspSource}; connect-src 'none';">
+    <link rel="stylesheet" href="${cssUri}">
+    <title>SDLC Pipeline Settings</title>
+</head>
+<body>
+    <div id="settings-root">
+        <header class="settings-header">
+            <h1>&#9881; SDLC Pipeline Settings</h1>
+            <p class="subtitle">Configure LLM provider and server connections</p>
+        </header>
+        <div class="tab-bar" role="tablist">
+            <button class="tab-btn active" id="tab-llm" data-tab="pane-llm" role="tab" aria-selected="true">&#129302; LLM Provider</button>
+            <button class="tab-btn" id="tab-server" data-tab="pane-server" role="tab" aria-selected="false">&#127760; Server Settings</button>
+        </div>
+        <div class="tab-pane active" id="pane-llm" role="tabpanel">
+            <section class="card" id="provider-section"><h2>&#129302; LLM Provider</h2><div class="provider-select-group"><label for="provider-select">Choose provider</label><select id="provider-select"><option value="anthropic">Anthropic — Claude models (recommended)</option><option value="openai">OpenAI — GPT models</option><option value="openrouter">OpenRouter — Multi-model gateway</option><option value="lmstudio">LM Studio — Local models</option><option value="ollama">Ollama — Local models (no API key needed)</option><option value="onnx">ONNX — CPU-only local (Phi-3, SmolLM2)</option></select></div></section>
+            <section class="card" id="api-section" style="display:none;"><h2>&#128273; API Configuration</h2><div class="form-group"><label for="api-key-input">API Key</label><div class="input-with-toggle"><input type="password" id="api-key-input" placeholder="Enter API key..." autocomplete="off"><button class="icon-btn" id="toggle-key-visibility" title="Show/Hide" aria-label="Toggle API key visibility">&#128065;</button></div><div id="key-status" class="status-indicator"></div></div><div class="form-group"><label for="base-url-input">Base URL <span style="opacity:0.6">(optional)</span></label><div class="checkbox-group" style="margin-bottom:6px;"><label><input type="checkbox" id="use-default-url-chk" checked> Use default URL for this provider</label></div><input type="text" id="base-url-input" placeholder="Leave empty for official API" disabled></div><div class="form-group"><label for="model-input">Model</label><select id="model-input"><option value="">— Select model —</option></select></div><div class="btn-row"><button id="save-key-btn" class="btn primary" disabled>Save API Key</button><button id="clear-key-btn" class="btn danger-outline">Clear Key</button></div></section>
+            <section class="card" id="ollama-section" style="display:none;"><h2>&#129433; Ollama Configuration</h2><div class="form-group"><label for="ollama-url-input">Server URL</label><input type="text" id="ollama-url-input" value="http://localhost:11434"></div><div class="form-group"><label for="ollama-model-input">Model</label><select id="ollama-model-input"><option value="">— Select model —</option></select></div><div class="btn-row"><button id="test-ollama-btn" class="btn secondary">Test Connection</button></div><div id="ollama-status" class="status-indicator"></div></section>
+            <section class="card" id="test-section"><h2>&#129514; Connection Test</h2><p class="card-desc">Send a test prompt to verify your LLM configuration works end-to-end.</p><div class="btn-row"><button id="test-llm-btn" class="btn primary">Test LLM</button></div><div id="test-result" class="test-result" style="display:none;"></div></section>
+        </div>
+        <div class="tab-pane" id="pane-server" role="tabpanel">
+            <section class="card" id="backend-mcp-section"><h2>&#127760; Backend MCP Server</h2><p class="card-desc">Configure the remote backend server URL.</p><div class="form-group"><label for="backend-url-input">Backend URL</label><input type="text" id="backend-url-input" placeholder="http://127.0.0.1:48721"></div><div class="btn-row"><button id="save-backend-url-btn" class="btn primary">Save URL</button><button id="test-backend-btn" class="btn secondary">Test Connection</button></div><div id="backend-test-result" class="status-indicator"></div></section>
+            <section class="card" id="wrapper-mcp-section"><h2>&#9881; MCP Wrapper Server (Local)</h2><p class="card-desc">Configure the local MCP wrapper server port.</p><div class="form-group"><label for="mcp-port-input">Wrapper Server Port</label><input type="number" id="mcp-port-input" min="1" max="65535" placeholder="9181"></div><div class="form-group checkbox-group"><label><input type="checkbox" id="enable-mcp-server-chk"> Enable MCP wrapper server on startup</label></div><div class="btn-row"><button id="save-wrapper-btn" class="btn primary">Save</button><button id="restart-mcp-btn" class="btn secondary">Restart Wrapper Server</button></div><div id="wrapper-result" class="status-indicator"></div></section>
+        </div>
+    </div>
+    <script nonce="${nonce}" src="${jsUri}"></script>
+</body>
+</html>`;
+  }
+}

package/extension/src/panels/settings-panel.ts ADDED Viewed

@@ -0,0 +1,10 @@
+/**
+ * Re-export SettingsPanel from new location for backward compatibility.
+ * Original code has been refactored into:
+ * - panels/settings/SettingsPanel.ts (panel creation + routing)
+ * - panels/settings/SettingsMessageHandler.ts (message handling)
+ * - services/LlmTestService.ts (LLM testing logic)
+ * - services/ProviderConfigService.ts (config read/write)
+ */
+export { SettingsPanel } from "./settings/SettingsPanel";

package/extension/src/panels/tags-panel.ts ADDED Viewed

@@ -0,0 +1,31 @@
+/**
+ * TagsPanel — Tag cloud and taxonomy tree with CRUD operations.
+ * Real-time updates via KbEventBus SSE subscription + polling fallback.
+ */
+import * as vscode from "vscode";
+import { WebviewToExtMessage, SERVER_CONSTANTS } from "../types";
+import { McpServerManager } from "../mcp-server-manager";
+import { BasePanel } from "./base-panel";
+import { KbEventBus } from "../kb-event-bus";
+export class TagsPanel extends BasePanel {
+  private refreshTimer: NodeJS.Timeout | undefined;
+  private eventSubscription: vscode.Disposable | undefined;
+  constructor(mcpManager: McpServerManager, extensionUri: vscode.Uri, eventBus?: KbEventBus) {
+    super("tags", mcpManager, extensionUri);
+  }
+  getHtml(webview: vscode.Webview): string {
+    return this.getIframeHtml();
+  }
+  async loadData(): Promise<void> {
+    // No-op
+  }
+  async handleMessage(msg: WebviewToExtMessage): Promise<void> {
+    // No-op
+  }
+}

package/extension/src/panels/workflow-panel.ts ADDED Viewed

@@ -0,0 +1,80 @@
+/**
+ * WorkflowPanel — Interactive D3.js + dagre visualization of the SDLC pipeline graph.
+ * Renders all LangGraph nodes, edges, and conditional routing in a VS Code webview.
+ * KSA-238
+ */
+import * as vscode from "vscode";
+import { WebviewToExtMessage } from "../types";
+import { McpServerManager } from "../mcp-server-manager";
+import { BasePanel } from "./base-panel";
+import { SDLC_GRAPH_DEFINITION } from "../langgraph/workflow-graph-data";
+export class WorkflowPanel extends BasePanel {
+  constructor(mcpManager: McpServerManager, extensionUri: vscode.Uri) {
+    super("workflow", mcpManager, extensionUri);
+  }
+  getHtml(webview: vscode.Webview): string {
+    const nonce = this.getNonce();
+    const cspSource = webview.cspSource;
+    const threeUri = this.getWebviewUri(webview, "webview-assets", "three.min.js");
+    const forceGraphUri = this.getWebviewUri(webview, "webview-assets", "3d-force-graph.min.js");
+    const cssUri = this.getWebviewUri(webview, "webview-assets", "workflow-graph.css");
+    const jsUri = this.getWebviewUri(webview, "webview-assets", "workflow-graph.js");
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}' 'unsafe-eval'; style-src ${cspSource} 'unsafe-inline'; img-src ${cspSource} data: blob:; connect-src 'none';">
+    <title>SDLC Workflow Graph</title>
+    <link rel="stylesheet" href="${cssUri}">
+</head>
+<body>
+    <div id="toolbar">
+      <button id="refresh-btn" title="Refresh">&#x21BB; Refresh</button>
+    </div>
+    <div id="phase-bar"></div>
+    <div id="graph-3d"></div>
+    <div id="node-info" class="hidden"></div>
+    <div id="graph-container" style="display:none"></div>
+    <div id="path-section" class="hidden" style="display:none"><div id="path-header"><span id="path-title"></span><button id="path-close"></button></div><div id="path-graph"></div></div>
+    <div id="node-detail" class="hidden" style="display:none"><div id="detail-header"><span id="detail-title"></span><button id="detail-close"></button></div><div id="detail-body"></div></div>
+    <script nonce="${nonce}" src="${threeUri}"></script>
+    <script nonce="${nonce}" src="${forceGraphUri}"></script>
+    <script nonce="${nonce}">
+      const vscode = acquireVsCodeApi();
+      window.addEventListener('message', (event) => {
+        const msg = event.data;
+        if (typeof handlePanelMessage === 'function') handlePanelMessage(msg);
+      });
+      vscode.postMessage({ type: 'ready' });
+    </script>
+    <script nonce="${nonce}" src="${jsUri}"></script>
+</body>
+</html>`;
+  }
+  async loadData(): Promise<void> {
+    this.sendMessage({
+      type: "workflowData",
+      nodes: SDLC_GRAPH_DEFINITION.nodes,
+      edges: SDLC_GRAPH_DEFINITION.edges,
+      metadata: SDLC_GRAPH_DEFINITION.metadata,
+    } as any);
+  }
+  async handleMessage(msg: WebviewToExtMessage): Promise<void> {
+    switch (msg.type) {
+      case "ready":
+        await this.loadData();
+        break;
+      case "refresh":
+        await this.loadData();
+        break;
+    }
+  }
+}