sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/langgraph/vscode-tools.ts

@@ -0,0 +1,146 @@
+/**
+ * VscodeTools — KSA-235: Execution logic for IDE-native tools.
+ * Tool definitions in vscode-tool-definitions.ts.
+ */
+import * as vscode from "vscode";
+import * as path from "path";
+export { VSCODE_TOOL_DEFINITIONS, isVscodeTool } from "./vscode-tool-definitions";
+
+export async function executeVscodeTool(name: string, args: Record<string, unknown>, workspaceRoot: string): Promise<string> {
+  const wsRoot = workspaceRoot || vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || "";
+  switch (name) {
+    case "read_file": return readFile(args, wsRoot);
+    case "list_directory": return listDirectory(args, wsRoot);
+    case "search_text": return searchText(args, wsRoot);
+    case "write_file": return writeFile(args, wsRoot);
+    case "get_diagnostics": return getDiagnostics(args, wsRoot);
+    case "get_open_files": return getOpenFiles();
+    default: return `Error: Unknown VS Code tool '${name}'`;
+  }
+}
+
+async function readFile(args: Record<string, unknown>, workspaceRoot: string): Promise<string> {
+  const filePath = args.path as string;
+  if (!filePath) return "Error: 'path' is required";
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
+  try {
+    const text = Buffer.from(await vscode.workspace.fs.readFile(vscode.Uri.file(fullPath))).toString("utf-8");
+    const startLine = args.start_line as number | undefined;
+    const endLine = args.end_line as number | undefined;
+    if (startLine || endLine) {
+      const lines = text.split("\n");
+      return lines.slice(Math.max(0, (startLine || 1) - 1), endLine ? Math.min(lines.length, endLine) : lines.length).join("\n");
+    }
+    return text.length > 50000 ? text.substring(0, 50000) + "\n\n[... truncated at 50KB ...]" : text;
+  } catch (error) { return `Error reading '${filePath}': ${(error as Error).message}`; }
+}
+
+async function listDirectory(args: Record<string, unknown>, workspaceRoot: string): Promise<string> {
+  const dirPath = (args.path as string) || ".";
+  const recursive = args.recursive as boolean || false;
+  const depth = (args.depth as number) || (recursive ? 2 : 1);
+  const fullPath = path.isAbsolute(dirPath) ? dirPath : path.join(workspaceRoot, dirPath);
+  const EXCLUDE = new Set([".git", "node_modules", "out", "dist", ".code-intel", ".pytest_cache", "__pycache__", ".vscode", ".github", ".kiro", ".antigravity", ".kilo", ".roo", ".gemini"]);
+  const EXCLUDE_EXT = new Set([".log", ".vsix"]);
+  const SOURCE_DIRS = new Set(["src", "lib", "app", "backend", "frontend", "packages", "services"]);
+
+  async function listRecursive(dir: string, currentDepth: number, prefix: string): Promise<string[]> {
+    if (currentDepth > depth) return [];
+    const results: string[] = [];
+    try {
+      const entries = await vscode.workspace.fs.readDirectory(vscode.Uri.file(dir));
+      for (const [name, type] of entries) {
+        if (EXCLUDE.has(name)) continue;
+        if (type === vscode.FileType.File && EXCLUDE_EXT.has(path.extname(name).toLowerCase())) continue;
+        const rel = prefix ? `${prefix}/${name}` : name;
+        results.push(`${type === vscode.FileType.Directory ? "d" : "f"} ${rel}`);
+        // Auto-expand source directories or when recursive requested
+        if (type === vscode.FileType.Directory && currentDepth < depth) {
+          const shouldExpand = recursive || (currentDepth === 1 && SOURCE_DIRS.has(name));
+          if (shouldExpand) {
+            const sub = await listRecursive(path.join(dir, name), currentDepth + 1, rel);
+            results.push(...sub);
+          }
+        }
+      }
+    } catch { /* skip */ }
+    return results;
+  }
+
+  try {
+    const results = await listRecursive(fullPath, 1, "");
+    const limit = (args.limit as number) || 30;
+    const offset = (args.offset as number) || 0;
+    const total = results.length;
+    const page = results.slice(offset, offset + limit);
+    const remaining = total - offset - page.length;
+    let output = page.join("\n") || "(empty directory)";
+    if (remaining > 0) {
+      output += `\n\n[${remaining} more entries. Use offset=${offset + limit} to see next page.]`;
+    }
+    if (offset > 0) {
+      output = `[Showing entries ${offset + 1}-${offset + page.length} of ${total}]\n` + output;
+    }
+    return output;
+  } catch (error) { return `Error listing '${dirPath}': ${(error as Error).message}`; }
+}
+
+async function searchText(args: Record<string, unknown>, workspaceRoot: string): Promise<string> {
+  const pattern = args.pattern as string;
+  if (!pattern) return "Error: 'pattern' is required";
+  const include = (args.include as string) || "**/*";
+  const maxResults = (args.max_results as number) || 20;
+  try {
+    const files = await vscode.workspace.findFiles(include, "**/node_modules/**", 100);
+    const results: string[] = [];
+    const regex = new RegExp(pattern, "gi");
+    for (const file of files) {
+      if (results.length >= maxResults) break;
+      try {
+        const lines = Buffer.from(await vscode.workspace.fs.readFile(file)).toString("utf-8").split("\n");
+        for (let i = 0; i < lines.length; i++) {
+          if (results.length >= maxResults) break;
+          if (regex.test(lines[i])) { results.push(`${vscode.workspace.asRelativePath(file)}:${i + 1}: ${lines[i].trim().substring(0, 200)}`); regex.lastIndex = 0; }
+        }
+      } catch { /* skip */ }
+    }
+    return results.length > 0 ? results.join("\n") : `No matches for '${pattern}'`;
+  } catch (error) { return `Error searching: ${(error as Error).message}`; }
+}
+
+async function writeFile(args: Record<string, unknown>, workspaceRoot: string): Promise<string> {
+  const filePath = args.path as string;
+  const content = args.content as string;
+  if (!filePath) return "Error: 'path' is required";
+  if (content === undefined) return "Error: 'content' is required";
+  const fullPath = path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
+  try {
+    const encoded = Buffer.from(content, "utf-8");
+    await vscode.workspace.fs.writeFile(vscode.Uri.file(fullPath), encoded);
+    return `File written: ${filePath} (${encoded.length} bytes)`;
+  } catch (error) { return `Error writing '${filePath}': ${(error as Error).message}`; }
+}
+
+async function getDiagnostics(args: Record<string, unknown>, workspaceRoot: string): Promise<string> {
+  const filePath = args.path as string | undefined;
+  if (filePath) {
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(workspaceRoot, filePath);
+    const diagnostics = vscode.languages.getDiagnostics(vscode.Uri.file(fullPath));
+    if (diagnostics.length === 0) return `No issues in ${filePath}`;
+    return diagnostics.map(d => `${filePath}:${d.range.start.line + 1}: [${vscode.DiagnosticSeverity[d.severity]}] ${d.message}`).join("\n");
+  }
+  const allDiags = vscode.languages.getDiagnostics();
+  const results: string[] = [];
+  for (const [uri, diagnostics] of allDiags) {
+    if (diagnostics.length === 0) continue;
+    for (const d of diagnostics) { results.push(`${vscode.workspace.asRelativePath(uri)}:${d.range.start.line + 1}: [${vscode.DiagnosticSeverity[d.severity]}] ${d.message}`); }
+  }
+  if (results.length === 0) return "No diagnostics in workspace";
+  return results.length > 50 ? results.slice(0, 50).join("\n") + `\n\n[... ${results.length - 50} more ...]` : results.join("\n");
+}
+
+async function getOpenFiles(): Promise<string> {
+  const tabs = vscode.window.tabGroups.all.flatMap(g => g.tabs);
+  const files = tabs.filter(t => t.input instanceof vscode.TabInputText).map(t => vscode.workspace.asRelativePath((t.input as vscode.TabInputText).uri));
+  return files.length > 0 ? files.join("\n") : "No files open";
+}

package/extension/src/langgraph/workflow-executor-actions.ts

@@ -0,0 +1,144 @@
+/**
+ * WorkflowExecutor action runners --- KSA-243
+ * Individual action execution logic extracted from WorkflowExecutor.
+ */
+
+import type { StepAction } from "./workflow-parser";
+import type { WorkflowNodeContext } from "./workflow-executor";
+import type { PipelineState } from "./state";
+import { loadSteeringRules, injectSteering } from "./steering-loader";
+
+export interface ExecutionContext {
+  ticketKey: string;
+  docType?: string;
+  templateContent: string;
+  jiraContext: string;
+  kbContext: string;
+  codeIntelContext: string;
+  skillContent: string;
+  generatedContent: string;
+  outputPath: string;
+  [key: string]: unknown;
+}
+
+export async function executeAction(
+  action: StepAction, ctx: ExecutionContext, state: PipelineState,
+  rolePrompt: string, node: WorkflowNodeContext
+): Promise<void> {
+  const ticketKey = ctx.ticketKey;
+  try {
+    switch (action.type) {
+      case "read_template": {
+        const path = resolvePath(action.params.path || "", ctx);
+        const content = await node.readWorkspaceFile(path);
+        if (content) ctx.templateContent = content;
+        break;
+      }
+      case "read_file": {
+        const path = resolvePath(action.params.path || "", ctx);
+        const content = await node.readWorkspaceFile(path);
+        if (content) {
+          const key = path.split("/").pop()?.replace(/\.\w+$/, "") || "file";
+          (ctx as Record<string, unknown>)[key] = content;
+        }
+        break;
+      }
+      case "fetch_jira": {
+        try { ctx.jiraContext = await node.getJiraIssue(ticketKey); } catch { ctx.jiraContext = "[Jira unavailable]"; }
+        break;
+      }
+      case "fetch_jira_recursive": {
+        try { ctx.jiraContext = await node.getJiraIssueRecursive(ticketKey, 2, 10); } catch { ctx.jiraContext = "[Jira unavailable]"; }
+        break;
+      }
+      case "kb_search": {
+        try {
+          const query = (action.params.query || `${ticketKey} context`).replace(/\{TICKET-KEY\}/g, ticketKey).replace(/\{TICKET\}/g, ticketKey);
+          ctx.kbContext += "\n" + await node.kbSearch(query);
+        } catch { /* */ }
+        break;
+      }
+      case "kb_ingest": {
+        await node.kbIngest(ctx.generatedContent.slice(0, 5000), "DOCUMENT", `workflow-${ctx.docType || "doc"}`, [ticketKey, ctx.docType || "document", "langgraph"]);
+        break;
+      }
+      case "kb_ingest_file": {
+        const path = resolvePath(action.params.path || ctx.outputPath, ctx);
+        await node.kbIngestFile(path);
+        break;
+      }
+      case "read_code_intelligence": {
+        ctx.codeIntelContext = await node.readCodeIntelligence() || "";
+        break;
+      }
+      case "generate_llm": {
+        const userPrompt = buildLlmPrompt(ctx, state);
+        const workspaceRoot = node.getWorkspaceRoot();
+        let systemPrompt = rolePrompt + (ctx.skillContent ? "\n\n" + ctx.skillContent : "");
+        if (workspaceRoot) {
+          const rules = await loadSteeringRules(workspaceRoot, "langgraph");
+          systemPrompt = injectSteering(systemPrompt, rules);
+        }
+        ctx.generatedContent = await node.callLlmStreamFull(systemPrompt, userPrompt, state);
+        break;
+      }
+      case "write_file": {
+        const path = resolvePath(action.params.path || ctx.outputPath, ctx);
+        if (ctx.generatedContent) await node.writeWorkspaceFile(path, ctx.generatedContent);
+        break;
+      }
+      case "append_file": {
+        const path = resolvePath(action.params.path || ctx.outputPath, ctx);
+        if (ctx.generatedContent) await node.appendWorkspaceFile(path, ctx.generatedContent);
+        break;
+      }
+      case "export_docx": {
+        const docxName = `${ctx.docType || "DOC"}-v1-${ticketKey}`;
+        await node.exportDocx(ctx.outputPath, docxName);
+        break;
+      }
+      case "export_drawio_png": {
+        const drawioPath = action.params.path || `documents/${ticketKey}/diagrams/`;
+        await node.exportDrawioPng(drawioPath);
+        break;
+      }
+      case "exec_shell": {
+        const command = (action.params.command || "").replace(/\{TICKET-KEY\}/g, ticketKey).replace(/\{TICKET\}/g, ticketKey);
+        if (command) { try { await node.execShell(command); } catch { /* */ } }
+        break;
+      }
+      case "exec_git": {
+        const args = (action.params.args || "").replace(/\{TICKET-KEY\}/g, ticketKey).replace(/\{TICKET\}/g, ticketKey);
+        if (args) { try { await node.execGit(args); } catch { /* */ } }
+        break;
+      }
+      case "discover_tools": {
+        await node.discoverTools("get issue details project tracker");
+        await node.discoverTools("search knowledge base");
+        break;
+      }
+      case "load_skill": {
+        const path = action.params.path || "";
+        if (path) { const content = await node.readWorkspaceFile(path); if (content) ctx.skillContent += "\n\n" + content; }
+        break;
+      }
+      default: break;
+    }
+  } catch { /* Individual action failure is non-blocking */ }
+}
+
+export function buildLlmPrompt(ctx: ExecutionContext, state: PipelineState): string {
+  const sections: string[] = [];
+  sections.push(`Create ${ctx.docType || "document"} for ticket ${ctx.ticketKey}.`);
+  if (ctx.templateContent) sections.push(`\n## TEMPLATE\n\n${ctx.templateContent}`);
+  if (ctx.jiraContext && !ctx.jiraContext.includes("unavailable")) sections.push(`\n## JIRA DATA\n\n${ctx.jiraContext.slice(0, 15000)}`);
+  if (ctx.kbContext.trim()) sections.push(`\n## KB CONTEXT\n\n${ctx.kbContext.slice(0, 5000)}`);
+  if (ctx.codeIntelContext) sections.push(`\n## CODE INTELLIGENCE\n\n${ctx.codeIntelContext.slice(0, 8000)}`);
+  const chatContext = state.chatHistory?.filter(m => m.role === "user").map(m => m.content).join("\n");
+  if (chatContext) sections.push(`\n## USER REQUIREMENTS\n\n${chatContext}`);
+  return sections.join("\n");
+}
+
+export function resolvePath(path: string, ctx: ExecutionContext): string {
+  return path.replace(/\{TICKET-KEY\}/g, ctx.ticketKey).replace(/\{TICKET\}/g, ctx.ticketKey);
+}

package/extension/src/langgraph/workflow-executor.ts

@@ -0,0 +1,87 @@
+/**
+ * WorkflowExecutor --- KSA-243
+ * Executes parsed workflow steps from agent .md files dynamically.
+ */
+
+import type { PipelineState } from "./state";
+import type { StreamHandler } from "./stream-handler";
+import { parseAgentWorkflow, type ParsedWorkflow, type WorkflowStep } from "./workflow-parser";
+import { ExecutionContext, executeAction } from "./workflow-executor-actions";
+
+/**
+ * Interface matching BaseNode utility methods that WorkflowExecutor needs.
+ */
+export interface WorkflowNodeContext {
+  readWorkspaceFile(path: string): Promise<string | null>;
+  writeWorkspaceFile(path: string, content: string): Promise<boolean>;
+  appendWorkspaceFile(path: string, content: string): Promise<boolean>;
+  getJiraIssue(issueKey: string): Promise<string>;
+  getJiraIssueRecursive(issueKey: string, maxDepth?: number, maxTickets?: number): Promise<string>;
+  kbSearch(query: string, limit?: number): Promise<string>;
+  kbIngest(content: string, type: string, source: string, tags: string[]): Promise<void>;
+  kbIngestFile(filePath: string, type?: string): Promise<void>;
+  readCodeIntelligence(moduleName?: string): Promise<string | null>;
+  exportDocx(mdPath: string, docxName: string): Promise<string | null>;
+  exportDrawioPng(drawioPath: string): Promise<boolean>;
+  execShell(command: string, cwd?: string): Promise<string>;
+  execGit(args: string): Promise<string>;
+  callLlmStreamFull(systemPrompt: string, userPrompt: string, state: PipelineState): Promise<string>;
+  discoverTools(query: string, threshold?: number, topK?: number): Promise<string>;
+  callMcp(toolName: string, args: Record<string, unknown>): Promise<string>;
+  getWorkspaceRoot(): string | null;
+  readonly streamHandler: StreamHandler;
+  readonly nodeId: string;
+}
+
+export class WorkflowExecutor {
+  constructor(private readonly node: WorkflowNodeContext) {}
+
+  async run(agentName: string, state: PipelineState, vars: Record<string, string> = {}): Promise<string> {
+    const agentContent = await this.node.readWorkspaceFile(`.kiro/agents/${agentName}.md`);
+    if (!agentContent) { throw new Error(`Agent file not found: .kiro/agents/${agentName}.md`); }
+    const workflow = parseAgentWorkflow(agentName, agentContent);
+    const skillContent = await this.loadSkills(workflow.skills);
+    const ctx: ExecutionContext = {
+      ticketKey: state.ticketKey, docType: vars.docType,
+      templateContent: "", jiraContext: "", kbContext: "", codeIntelContext: "",
+      skillContent, generatedContent: "", outputPath: vars.outputPath || `documents/${state.ticketKey}/`, ...vars,
+    };
+    this.emitStatus(`[${agentName}] Executing ${workflow.steps.length} steps dynamically...`, state);
+    for (const step of workflow.steps) {
+      if (step.isConditional && step.condition) {
+        if (!this.evaluateCondition(step.condition, ctx)) {
+          this.emitStatus(`  skip ${step.id}: ${step.title}`, state);
+          continue;
+        }
+      }
+      this.emitStatus(`  -> ${step.id}: ${step.title}`, state);
+      for (const action of step.actions) {
+        await executeAction(action, ctx, state, workflow.rolePrompt, this.node);
+      }
+    }
+    return ctx.generatedContent;
+  }
+
+  private async loadSkills(skillPaths: string[]): Promise<string> {
+    const contents: string[] = [];
+    for (const path of skillPaths) {
+      const content = await this.node.readWorkspaceFile(path);
+      if (content) {
+        const fmMatch = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n([\s\S]*)$/);
+        contents.push(fmMatch ? fmMatch[1].trim() : content.trim());
+      }
+    }
+    return contents.join("\n\n---\n\n");
+  }
+
+  private evaluateCondition(condition: string, ctx: ExecutionContext): boolean {
+    const lower = condition.toLowerCase();
+    if (lower.includes("fsd") && ctx.docType !== "FSD") return false;
+    if (lower.includes("brd") && ctx.docType !== "BRD") return false;
+    return true;
+  }
+
+  private emitStatus(message: string, state: PipelineState): void {
+    this.node.streamHandler.emitToken(this.node.nodeId, message, state.currentStreamId);
+  }
+}

package/extension/src/langgraph/workflow-graph-data.ts

@@ -0,0 +1,132 @@
+/**
+ * Static SDLC Graph Definition for Workflow Visualization Panel (KSA-238).
+ * Mirrors the structure defined in sdlc-graph.ts for rendering purposes.
+ */
+
+export interface WorkflowNode {
+  id: string;
+  label: string;
+  type: "agent" | "quality_gate" | "verify" | "security" | "control";
+  agentClass?: string;
+  description?: string;
+}
+
+export interface WorkflowEdge {
+  source: string;
+  target: string;
+  type: "direct" | "conditional";
+  label?: string;
+  routingFn?: string;
+}
+
+export interface WorkflowGraphData {
+  nodes: WorkflowNode[];
+  edges: WorkflowEdge[];
+  metadata: { totalNodes: number; totalEdges: number; generatedAt: string };
+}
+
+export const SDLC_GRAPH_DEFINITION: WorkflowGraphData = {
+  nodes: [
+    { id: "sm", label: "SM: Orchestrator", type: "agent", agentClass: "SmNode", description: "Routes to appropriate phase" },
+    { id: "ba_brd", label: "BA: BRD", type: "agent", agentClass: "BaNode", description: "Creates BRD" },
+    { id: "ba_fsd", label: "BA: FSD", type: "agent", agentClass: "BaNode", description: "Creates FSD" },
+    { id: "ta_enrich", label: "TA: Enrich FSD", type: "agent", agentClass: "TaNode", description: "Enriches FSD technically" },
+    { id: "sa_tdd", label: "SA: TDD", type: "agent", agentClass: "SaNode", description: "Creates TDD" },
+    { id: "qa_plan", label: "QA: Test Plan", type: "agent", agentClass: "QaNode", description: "Creates STP + STC" },
+    { id: "dev_code", label: "DEV: Code", type: "agent", agentClass: "DevNode", description: "Implements code" },
+    { id: "dev_ug", label: "DEV: User Guide", type: "agent", agentClass: "DevNode", description: "Writes User Guide" },
+    { id: "ba_review_ug", label: "BA: Review UG", type: "agent", agentClass: "BaNode", description: "Reviews UG" },
+    { id: "qa_verify_ug", label: "QA: Verify UG", type: "agent", agentClass: "QaNode", description: "Verifies UG" },
+    { id: "qa_test", label: "QA: Test", type: "agent", agentClass: "QaNode", description: "Executes tests" },
+    { id: "devops_deploy", label: "DevOps: Deploy", type: "agent", agentClass: "DevOpsNode", description: "Deploys and releases" },
+    { id: "ba_fix_fsd", label: "BA: Fix FSD", type: "agent", agentClass: "BaNode", description: "Fixes FSD discrepancies" },
+    { id: "sa_review", label: "SA: Review", type: "agent", agentClass: "SaNode", description: "Re-reviews after fix" },
+    { id: "security_review_fsd", label: "Security: FSD", type: "security", agentClass: "SecurityNode" },
+    { id: "security_review_tdd", label: "Security: TDD", type: "security", agentClass: "SecurityNode" },
+    { id: "security_review_code", label: "Security: Code", type: "security", agentClass: "SecurityNode" },
+    { id: "quality_gate_requirements", label: "QG: Requirements", type: "quality_gate" },
+    { id: "quality_gate_specification", label: "QG: Specification", type: "quality_gate" },
+    { id: "quality_gate_design", label: "QG: Design", type: "quality_gate" },
+    { id: "quality_gate_test_planning", label: "QG: Test Planning", type: "quality_gate" },
+    { id: "quality_gate_implementation", label: "QG: Implementation", type: "quality_gate" },
+    { id: "quality_gate_user_guide", label: "QG: User Guide", type: "quality_gate" },
+    { id: "quality_gate_testing", label: "QG: Testing", type: "quality_gate" },
+    { id: "quality_gate_deployment", label: "QG: Deployment", type: "quality_gate" },
+    { id: "verify_ba_brd", label: "Verify: BRD", type: "verify" },
+    { id: "verify_ba_fsd", label: "Verify: FSD", type: "verify" },
+    { id: "verify_sa_tdd", label: "Verify: TDD", type: "verify" },
+    { id: "verify_qa_plan", label: "Verify: QA Plan", type: "verify" },
+    { id: "verify_dev_code", label: "Verify: Code", type: "verify" },
+    { id: "verify_dev_ug", label: "Verify: UG", type: "verify" },
+    { id: "feedback_check", label: "Feedback Check", type: "control" },
+    { id: "ug_join", label: "UG Join", type: "control" },
+    { id: "strategy_switch", label: "Strategy Switch", type: "control" },
+    { id: "__start__", label: "START", type: "control" },
+  ],
+  edges: [
+    { source: "__start__", target: "sm", type: "direct" },
+    { source: "sm", target: "ba_brd", type: "conditional", label: "ba_brd", routingFn: "routeFromSm" },
+    { source: "sm", target: "ba_fsd", type: "conditional", label: "ba_fsd", routingFn: "routeFromSm" },
+    { source: "sm", target: "sa_tdd", type: "conditional", label: "sa_tdd", routingFn: "routeFromSm" },
+    { source: "sm", target: "qa_plan", type: "conditional", label: "qa_plan", routingFn: "routeFromSm" },
+    { source: "sm", target: "dev_code", type: "conditional", label: "dev_code", routingFn: "routeFromSm" },
+    { source: "sm", target: "dev_ug", type: "conditional", label: "dev_ug", routingFn: "routeFromSm" },
+    { source: "sm", target: "qa_test", type: "conditional", label: "qa_test", routingFn: "routeFromSm" },
+    { source: "sm", target: "devops_deploy", type: "conditional", label: "devops_deploy", routingFn: "routeFromSm" },
+    { source: "ba_brd", target: "verify_ba_brd", type: "direct" },
+    { source: "verify_ba_brd", target: "quality_gate_requirements", type: "conditional", label: "pass" },
+    { source: "verify_ba_brd", target: "ba_brd", type: "conditional", label: "retry" },
+    { source: "verify_ba_brd", target: "strategy_switch", type: "conditional", label: "max_retries" },
+    { source: "quality_gate_requirements", target: "sm", type: "conditional", label: "approved" },
+    { source: "quality_gate_requirements", target: "ba_brd", type: "conditional", label: "rejected" },
+    { source: "ba_fsd", target: "verify_ba_fsd", type: "direct" },
+    { source: "verify_ba_fsd", target: "ta_enrich", type: "conditional", label: "pass" },
+    { source: "verify_ba_fsd", target: "ba_fsd", type: "conditional", label: "retry" },
+    { source: "verify_ba_fsd", target: "strategy_switch", type: "conditional", label: "max_retries" },
+    { source: "ta_enrich", target: "security_review_fsd", type: "direct" },
+    { source: "security_review_fsd", target: "quality_gate_specification", type: "conditional", label: "pass" },
+    { source: "quality_gate_specification", target: "sm", type: "conditional", label: "approved" },
+    { source: "quality_gate_specification", target: "ba_fsd", type: "conditional", label: "rejected" },
+    { source: "sa_tdd", target: "verify_sa_tdd", type: "direct" },
+    { source: "verify_sa_tdd", target: "feedback_check", type: "conditional", label: "pass" },
+    { source: "verify_sa_tdd", target: "sa_tdd", type: "conditional", label: "retry" },
+    { source: "verify_sa_tdd", target: "strategy_switch", type: "conditional", label: "max_retries" },
+    { source: "feedback_check", target: "security_review_tdd", type: "conditional", label: "no_discrepancy" },
+    { source: "feedback_check", target: "ba_fix_fsd", type: "conditional", label: "has_discrepancy" },
+    { source: "ba_fix_fsd", target: "sa_review", type: "direct" },
+    { source: "sa_review", target: "feedback_check", type: "conditional", label: "re-check" },
+    { source: "security_review_tdd", target: "quality_gate_design", type: "direct" },
+    { source: "quality_gate_design", target: "sm", type: "conditional", label: "approved" },
+    { source: "quality_gate_design", target: "sa_tdd", type: "conditional", label: "rejected" },
+    { source: "qa_plan", target: "verify_qa_plan", type: "direct" },
+    { source: "verify_qa_plan", target: "quality_gate_test_planning", type: "conditional", label: "pass" },
+    { source: "verify_qa_plan", target: "qa_plan", type: "conditional", label: "retry" },
+    { source: "quality_gate_test_planning", target: "sm", type: "conditional", label: "approved" },
+    { source: "dev_code", target: "verify_dev_code", type: "direct" },
+    { source: "verify_dev_code", target: "security_review_code", type: "conditional", label: "pass" },
+    { source: "verify_dev_code", target: "dev_code", type: "conditional", label: "retry" },
+    { source: "security_review_code", target: "quality_gate_implementation", type: "conditional", label: "pass" },
+    { source: "quality_gate_implementation", target: "sm", type: "conditional", label: "approved" },
+    { source: "dev_ug", target: "verify_dev_ug", type: "direct" },
+    { source: "verify_dev_ug", target: "ba_review_ug", type: "conditional", label: "pass" },
+    { source: "verify_dev_ug", target: "dev_ug", type: "conditional", label: "retry" },
+    { source: "ba_review_ug", target: "qa_verify_ug", type: "conditional", label: "pass" },
+    { source: "qa_verify_ug", target: "ug_join", type: "conditional", label: "pass" },
+    { source: "ug_join", target: "quality_gate_user_guide", type: "conditional", label: "complete" },
+    { source: "quality_gate_user_guide", target: "sm", type: "conditional", label: "approved" },
+    { source: "qa_test", target: "quality_gate_testing", type: "conditional", label: "pass" },
+    { source: "quality_gate_testing", target: "sm", type: "conditional", label: "approved" },
+    { source: "devops_deploy", target: "quality_gate_deployment", type: "conditional", label: "pass" },
+    { source: "quality_gate_deployment", target: "sm", type: "conditional", label: "approved" },
+    { source: "strategy_switch", target: "ba_brd", type: "conditional", label: "retry_alternate" },
+    { source: "strategy_switch", target: "ba_fsd", type: "conditional", label: "retry_alternate" },
+    { source: "strategy_switch", target: "sa_tdd", type: "conditional", label: "retry_alternate" },
+    { source: "strategy_switch", target: "dev_code", type: "conditional", label: "retry_alternate" },
+    { source: "strategy_switch", target: "dev_ug", type: "conditional", label: "retry_alternate" },
+  ],
+  metadata: {
+    totalNodes: 35,
+    totalEdges: 59,
+    generatedAt: new Date().toISOString(),
+  },
+};

package/extension/src/langgraph/workflow-parser-actions.ts

@@ -0,0 +1,87 @@
+/**
+ * WorkflowParser action patterns --- KSA-243
+ * Keyword-to-ActionType mapping and helper extractors.
+ */
+
+export type ActionType =
+  | "read_template" | "read_file" | "fetch_jira" | "fetch_jira_recursive"
+  | "kb_search" | "kb_ingest" | "kb_ingest_file" | "read_code_intelligence"
+  | "generate_llm" | "write_file" | "append_file" | "export_docx"
+  | "export_drawio_png" | "exec_shell" | "exec_git" | "discover_tools"
+  | "load_skill" | "stream_status" | "validate" | "unknown";
+
+export interface StepAction {
+  type: ActionType;
+  description: string;
+  params: Record<string, string>;
+}
+
+interface ActionPattern {
+  pattern: RegExp;
+  type: ActionType;
+  paramExtractor?: (match: RegExpMatchArray, line: string) => Record<string, string>;
+}
+
+export const ACTION_PATTERNS: ActionPattern[] = [
+  { pattern: /read.*template|template.*read/i, type: "read_template", paramExtractor: (_m, line) => ({ path: extractPath(line) || "documents/templates/" }) },
+  { pattern: /readFile|read\s+.*\.(md|txt|yml|yaml|json|kt|ts)/i, type: "read_file", paramExtractor: (_m, line) => ({ path: extractPath(line) || "" }) },
+  { pattern: /fetch.*jira.*recursive|linked.*ticket.*recursive/i, type: "fetch_jira_recursive" },
+  { pattern: /fetch.*ticket|get.*issue|jira.*ticket/i, type: "fetch_jira" },
+  { pattern: /mem_search|kb.*search|knowledge.*base.*search|search.*KB/i, type: "kb_search", paramExtractor: (_m, line) => ({ query: extractQuoted(line) || "" }) },
+  { pattern: /mem_ingest_file|ingest.*file.*KB/i, type: "kb_ingest_file", paramExtractor: (_m, line) => ({ path: extractPath(line) || "" }) },
+  { pattern: /mem_ingest|ingest.*KB|KB.*ingest|knowledge.*base.*ingest/i, type: "kb_ingest" },
+  { pattern: /code.?intelligence|\.analysis\/code-intelligence/i, type: "read_code_intelligence" },
+  { pattern: /generate.*BRD|generate.*FSD|generate.*TDD|generate.*document|create.*document|LLM.*generat/i, type: "generate_llm" },
+  { pattern: /stream_write_file|write.*file|create.*at.*documents\//i, type: "write_file", paramExtractor: (_m, line) => ({ path: extractPath(line) || "" }) },
+  { pattern: /export_docx|export.*DOCX|MS\s*Word/i, type: "export_docx" },
+  { pattern: /export.*PNG|draw\.io.*export|drawio_export_png/i, type: "export_drawio_png" },
+  { pattern: /executePwsh|exec.*shell|run.*command|npm.*run|gradlew/i, type: "exec_shell", paramExtractor: (_m, line) => ({ command: extractCommand(line) || "" }) },
+  { pattern: /git\s+(checkout|add|commit|push|branch)/i, type: "exec_git", paramExtractor: (_m, line) => ({ args: extractGitArgs(line) || "" }) },
+  { pattern: /find_tools|discover.*tools/i, type: "discover_tools" },
+  { pattern: /\.kiro\/steering\/.*\.md|contextFiles|load.*skill/i, type: "load_skill", paramExtractor: (_m, line) => ({ path: extractSteeringPath(line) || "" }) },
+];
+
+/** Infer action type from a single line of text. */
+export function inferActions(line: string): StepAction[] {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("<!--") || trimmed === "---") return [];
+  for (const { pattern, type, paramExtractor } of ACTION_PATTERNS) {
+    const match = trimmed.match(pattern);
+    if (match) {
+      return [{ type, description: trimmed, params: paramExtractor ? paramExtractor(match, trimmed) : {} }];
+    }
+  }
+  return [];
+}
+
+// === Helper extractors ===
+
+function extractPath(line: string): string | null {
+  const match = line.match(/[`"']?((?:documents|\.analysis|\.kiro)\/[^\s`"',)]+)[`"']?/);
+  return match ? match[1] : null;
+}
+
+function extractQuoted(line: string): string | null {
+  const match = line.match(/["']([^"']+)["']/);
+  return match ? match[1] : null;
+}
+
+function extractCommand(line: string): string | null {
+  const match = line.match(/`([^`]+)`/) || line.match(/(?:run|execute)\s+(.+)/i);
+  return match ? match[1].trim() : null;
+}
+
+function extractGitArgs(line: string): string | null {
+  const match = line.match(/git\s+(.+)/i);
+  return match ? match[1].trim() : null;
+}
+
+function extractSteeringPath(line: string): string | null {
+  const match = line.match(/(\.kiro\/steering\/[\w-]+\.md)/);
+  return match ? match[1] : null;
+}
+
+export function extractCondition(title: string): string | undefined {
+  const match = title.match(/\((?:if|only\s+for|when)\s+([^)]+)\)/i);
+  return match ? match[1] : undefined;
+}