sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/langgraph/state.ts

@@ -0,0 +1,61 @@
+/**
+ * LangGraph Pipeline State --- KSA-210
+ * Typed state channels for the SDLC pipeline StateGraph.
+ */
+
+import { Annotation } from "@langchain/langgraph";
+import type { LlmToolCall, LlmMessage } from "./llm-provider";
+
+export type { LlmToolCall } from "./llm-provider";
+export {
+  SDLCPhase, PipelineIntent, PipelineStatus, ApprovalDecision, StreamEventType,
+  StrategyEvent, DocumentState, AgentOutput, QualityGateCheckpoint, QualityGateResult,
+  ChatMessage, PipelineError, PipelineGraphNode, PersistedPipelineInfo,
+} from "./state-types";
+
+import type {
+  SDLCPhase, PipelineIntent, PipelineStatus, ApprovalDecision,
+  StrategyEvent, DocumentState, AgentOutput, QualityGateCheckpoint, QualityGateResult,
+  ChatMessage, PipelineError,
+} from "./state-types";
+
+export const PipelineAnnotation = Annotation.Root({
+  ticketKey: Annotation<string>,
+  threadId: Annotation<string>,
+  currentPhase: Annotation<SDLCPhase>,
+  intent: Annotation<PipelineIntent>({ reducer: (_existing, update) => update, default: () => "chat" as PipelineIntent }),
+  pipelineStatus: Annotation<PipelineStatus>,
+  resumePoint: Annotation<string | null>,
+  documents: Annotation<Record<string, DocumentState>>,
+  agentOutputs: Annotation<AgentOutput[]>({ reducer: (_existing, update) => update, default: () => [] }),
+  currentStreamId: Annotation<string | null>,
+  approvalRequired: Annotation<boolean>,
+  approvalDecision: Annotation<ApprovalDecision | null>,
+  userFeedback: Annotation<string | null>,
+  pendingApprovals: Annotation<QualityGateCheckpoint[]>,
+  chatHistory: Annotation<ChatMessage[]>({ reducer: (existing, update) => [...existing, ...update].slice(-200), default: () => [] }),
+  errors: Annotation<PipelineError[]>,
+  retryCount: Annotation<Record<string, number>>,
+  createdAt: Annotation<string>,
+  lastUpdatedAt: Annotation<string>,
+  lastCheckpointAt: Annotation<string | null>,
+  feedbackIterations: Annotation<number>({ reducer: (_e, u) => u, default: () => 0 }),
+  maxFeedbackIterations: Annotation<number>({ reducer: (_e, u) => u, default: () => 5 }),
+  discrepancyFound: Annotation<boolean>({ reducer: (_e, u) => u, default: () => false }),
+  previousNode: Annotation<string | null>({ reducer: (_e, u) => u, default: () => null }),
+  parallelResults: Annotation<Record<string, string>>({ reducer: (e, u) => ({ ...e, ...u }), default: () => ({}) }),
+  qualityGateResults: Annotation<Record<string, QualityGateResult>>({ reducer: (e, u) => ({ ...e, ...u }), default: () => ({}) }),
+  toolCalls: Annotation<LlmToolCall[] | null>({ reducer: (_e, u) => u, default: () => null }),
+  toolResults: Annotation<Array<{ toolCallId: string; name: string; content: string }>>({ reducer: (e, u) => [...e, ...u], default: () => [] }),
+  agentScratchpad: Annotation<LlmMessage[]>({ reducer: (_e, u) => u, default: () => [] }),
+  agentIterations: Annotation<number>({ reducer: (_e, u) => u, default: () => 0 }),
+  verifyPassed: Annotation<boolean>({ reducer: (_e, u) => u, default: () => true }),
+  verifyFeedback: Annotation<string | null>({ reducer: (_e, u) => u, default: () => null }),
+  verifyAttempts: Annotation<Record<string, number>>({ reducer: (e, u) => ({ ...e, ...u }), default: () => ({}) }),
+  maxVerifyAttempts: Annotation<number>({ reducer: (_e, u) => u, default: () => 2 }),
+  activeStrategy: Annotation<Record<string, string>>({ reducer: (e, u) => ({ ...e, ...u }), default: () => ({}) }),
+  strategyHistory: Annotation<StrategyEvent[]>({ reducer: (e, u) => [...e, ...u].slice(-20), default: () => [] }),
+  maxContextTokens: Annotation<number>({ reducer: (_e, u) => u, default: () => 0 }),
+});
+
+export type PipelineState = typeof PipelineAnnotation.State;

package/extension/src/langgraph/steering-loader.ts

@@ -0,0 +1,192 @@
+// SteeringLoader --- KSA-217, KSA-242 --- Parses .kiro/steering/ files recursively
+import * as vscode from "vscode";
+import * as path from "path";
+
+export interface SteeringRule {
+  /** File path relative to workspace */
+  filePath: string;
+  /** Front-matter metadata */
+  meta: SteeringMeta;
+  /** Markdown content (body without front-matter) */
+  content: string;
+}
+
+export interface SteeringMeta {
+  /** Which system this rule targets: kiro (IDE agent), langgraph (pipeline), or all */
+  targets: "kiro" | "langgraph" | "all";
+  /** Inclusion strategy: always, auto, fileMatch, manual */
+  inclusion: "always" | "auto" | "fileMatch" | "manual";
+  /** Glob pattern for fileMatch inclusion */
+  fileMatchPattern?: string;
+  /** Human-readable title */
+  title?: string;
+  /** Priority (higher = injected first). Default 0. */
+  priority?: number;
+}
+
+const FRONT_MATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+
+const AUTO_INJECT_INCLUSIONS: Set<string> = new Set(["always", "auto"]);
+
+export async function loadSteeringRules(
+  workspaceRoot: string,
+  target: "kiro" | "langgraph" = "langgraph"
+): Promise<SteeringRule[]> {
+  const steeringDir = path.join(workspaceRoot, ".kiro", "steering");
+
+  try {
+    const rules: SteeringRule[] = [];
+    await scanDirectoryRecursive(steeringDir, steeringDir, target, rules);
+
+    // Sort by priority (descending)
+    rules.sort((a, b) => (b.meta.priority ?? 0) - (a.meta.priority ?? 0));
+
+    return rules;
+  } catch {
+    return [];
+  }
+}
+
+async function scanDirectoryRecursive(
+  currentDir: string,
+  rootSteeringDir: string,
+  target: "kiro" | "langgraph" | "all",
+  rules: SteeringRule[]
+): Promise<void> {
+  const dirUri = vscode.Uri.file(currentDir);
+  let entries: [string, vscode.FileType][];
+
+  try {
+    entries = await vscode.workspace.fs.readDirectory(dirUri);
+  } catch {
+    return; // Directory unreadable, skip
+  }
+
+  for (const [name, type] of entries) {
+    const fullPath = path.join(currentDir, name);
+
+    if (type === vscode.FileType.Directory) {
+      // Recurse into subdirectory
+      await scanDirectoryRecursive(fullPath, rootSteeringDir, target, rules);
+    } else if (type === vscode.FileType.File && name.endsWith(".md")) {
+      // Process markdown file
+      const content = await readFileContent(fullPath);
+      if (!content) continue;
+
+      // Build relative path from .kiro/steering/ root
+      const relativePath = path.relative(
+        path.join(rootSteeringDir, ".."), // parent of steering = .kiro
+        fullPath
+      ).replace(/\\/g, "/");
+      const filePath = `.kiro/${relativePath}`;
+
+      const parsed = parseSteeringFile(content, filePath);
+      if (!parsed) continue;
+
+      // Filter by target
+      if (parsed.meta.targets === "all" || parsed.meta.targets === target) {
+        if (AUTO_INJECT_INCLUSIONS.has(parsed.meta.inclusion)) {
+          rules.push(parsed);
+        }
+      }
+    }
+  }
+}
+
+export function injectSteering(basePrompt: string, rules: SteeringRule[]): string {
+  if (rules.length === 0) return basePrompt;
+
+  // Budget: limit total steering injection to ~4000 chars (~1000 tokens)
+  // to leave room for user messages in small context models
+  const MAX_STEERING_CHARS = 4000;
+
+  let totalChars = 0;
+  const includedBlocks: string[] = [];
+
+  for (const r of rules) {
+    const header = r.meta.title ? `## ${r.meta.title}` : `## ${r.filePath}`;
+    const block = `${header}\n\n${r.content}`;
+    if (totalChars + block.length > MAX_STEERING_CHARS) { break; }
+    includedBlocks.push(block);
+    totalChars += block.length;
+  }
+
+  if (includedBlocks.length === 0) return basePrompt;
+
+  const steeringBlock = includedBlocks.join("\n\n---\n\n");
+  return `${basePrompt}\n\n# Steering Rules (auto-injected)\n\n${steeringBlock}`;
+}
+
+export function parseSteeringFile(raw: string, filePath: string): SteeringRule | null {
+  const match = raw.match(FRONT_MATTER_REGEX);
+
+  if (match) {
+    const frontMatter = match[1];
+    const body = match[2].trim();
+    const meta = parseFrontMatter(frontMatter);
+    return { filePath, meta, content: body };
+  }
+
+  // KSA-279: No front-matter -> conservative default for pipeline.
+  // Files without explicit inclusion should NOT flood the pipeline context.
+  // Pipeline agents already receive role-specific prompts; only files that
+  // EXPLICITLY declare inclusion: always/auto should auto-inject.
+  return {
+    filePath,
+    meta: {
+      targets: "all",
+      inclusion: "manual",
+    },
+    content: raw.trim(),
+  };
+}
+
+function parseFrontMatter(raw: string): SteeringMeta {
+  const meta: SteeringMeta = {
+    targets: "all",
+    inclusion: "always",
+  };
+
+  const lines = raw.split(/\r?\n/);
+  for (const line of lines) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+
+    const key = line.slice(0, colonIdx).trim().toLowerCase();
+    const value = line.slice(colonIdx + 1).trim().replace(/^["']|["']$/g, "");
+
+    switch (key) {
+      case "targets":
+        if (value === "kiro" || value === "langgraph" || value === "all") {
+          meta.targets = value;
+        }
+        break;
+      case "inclusion":
+        if (value === "always" || value === "auto" || value === "filematch" || value === "manual") {
+          meta.inclusion = value.toLowerCase() as SteeringMeta["inclusion"];
+        }
+        break;
+      case "filematchpattern":
+        meta.fileMatchPattern = value;
+        break;
+      case "title":
+        meta.title = value;
+        break;
+      case "priority":
+        meta.priority = parseInt(value, 10) || 0;
+        break;
+    }
+  }
+
+  return meta;
+}
+
+async function readFileContent(filePath: string): Promise<string | null> {
+  try {
+    const uri = vscode.Uri.file(filePath);
+    const bytes = await vscode.workspace.fs.readFile(uri);
+    return Buffer.from(bytes).toString("utf-8");
+  } catch {
+    return null;
+  }
+}

package/extension/src/langgraph/stream-handler.ts

@@ -0,0 +1,185 @@
+/**
+ * StreamHandler — KSA-210
+ * Bridges LangGraph node events to Chat Panel postMessage protocol.
+ * Token events are debounced (50ms); status/complete/error flush immediately.
+ */
+
+import { ChatExtToWebviewMessage } from "../chat-panel/message-protocol";
+
+/** Maximum buffer size to prevent memory issues */
+const MAX_BUFFER_SIZE = 100;
+
+export class StreamHandler {
+  private buffer: ChatExtToWebviewMessage[] = [];
+  private flushTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly DEBOUNCE_MS = 50;
+
+  constructor(private readonly emit: (msg: ChatExtToWebviewMessage) => void) {}
+
+  /** Buffer token events, flush on debounce window */
+  emitToken(nodeId: string, content: string, streamId: string | null): void {
+    this.buffer.push({
+      type: "chat:streamChunk",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      eventType: "token",
+      content,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Prevent unbounded buffer growth
+    if (this.buffer.length > MAX_BUFFER_SIZE) {
+      this.flush();
+      return;
+    }
+
+    this.scheduleFlush();
+  }
+
+  /** Immediately flush on status events */
+  emitStatus(nodeId: string, status: string, streamId: string | null): void {
+    this.flush(); // Flush any pending tokens first
+    this.emit({
+      type: "chat:streamChunk",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      eventType: "status",
+      content: status,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Immediately flush on complete events */
+  emitComplete(nodeId: string, duration: number, streamId: string | null): void {
+    this.flush();
+    this.emit({
+      type: "chat:streamComplete",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      finalContent: `Node ${nodeId} completed in ${duration}ms`,
+      metadata: { duration },
+    });
+  }
+
+  /** Immediately flush on error events */
+  emitError(nodeId: string, error: string, streamId: string | null): void {
+    this.flush();
+    this.emit({
+      type: "chat:streamChunk",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      eventType: "error",
+      content: error,
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  // === Self-Correction Events (KSA-233) ===
+
+  /** Emit retry event — immediate flush (not buffered) */
+  emitRetry(
+    nodeId: string,
+    attempt: number,
+    maxAttempts: number,
+    delayMs: number,
+    error: string,
+    streamId: string | null
+  ): void {
+    this.flush();
+    this.emit({
+      type: "chat:streamChunk",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      eventType: "retry",
+      content: JSON.stringify({ attempt, maxAttempts, delayMs, error }),
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Emit verify event — immediate flush */
+  emitVerify(
+    nodeId: string,
+    passed: boolean,
+    feedback: string | null,
+    attempt: number,
+    streamId: string | null
+  ): void {
+    this.flush();
+    this.emit({
+      type: "chat:streamChunk",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      eventType: "verify",
+      content: JSON.stringify({ passed, feedback, attempt }),
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Emit strategy switch event — immediate flush */
+  emitStrategySwitch(
+    nodeId: string,
+    fromStrategy: string,
+    toStrategy: string,
+    reason: string,
+    streamId: string | null
+  ): void {
+    this.flush();
+    this.emit({
+      type: "chat:streamChunk",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      eventType: "strategy_switch",
+      content: JSON.stringify({ fromStrategy, toStrategy, reason }),
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Emit human intervention required event — immediate flush */
+  emitHumanIntervention(
+    nodeId: string,
+    failedStrategies: string[],
+    verifyHistory: Array<{ attempt: number; feedback: string }>,
+    streamId: string | null
+  ): void {
+    this.flush();
+    this.emit({
+      type: "chat:streamChunk",
+      streamId: streamId ?? `stream-${nodeId}-${Date.now()}`,
+      nodeId,
+      eventType: "human_intervention_required",
+      content: JSON.stringify({ failedStrategies, verifyHistory }),
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  /** Dispose: flush remaining and cancel timer */
+  dispose(): void {
+    this.flush();
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+
+  /** Emit a raw message directly (used for toolCall messages) */
+  emitDirect(msg: ChatExtToWebviewMessage): void {
+    this.flush();
+    this.emit(msg);
+  }
+
+  private scheduleFlush(): void {
+    if (this.flushTimer) { return; }
+    this.flushTimer = setTimeout(() => this.flush(), this.DEBOUNCE_MS);
+  }
+
+  private flush(): void {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    const messages = this.buffer.splice(0);
+    for (const msg of messages) {
+      this.emit(msg);
+    }
+  }
+}

package/extension/src/langgraph/tool-registry.ts

@@ -0,0 +1,85 @@
+/**
+ * ToolRegistry — Fetches ALL tools from MCP server and caches them.
+ * Provides tool definitions in LLM-compatible formats (Anthropic, OpenAI, Ollama).
+ */
+
+import { McpBridge } from "./mcp-bridge";
+
+/** Raw MCP tool definition from tools/list response */
+export interface McpToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+/** Anthropic tool format */
+export interface AnthropicTool {
+  name: string;
+  description: string;
+  input_schema: Record<string, unknown>;
+}
+
+/** OpenAI/Ollama function format */
+export interface OpenAIFunction {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+
+export class ToolRegistry {
+  private tools: McpToolDefinition[] | null = null;
+
+  constructor(private readonly mcpBridge: McpBridge) {}
+
+  /**
+   * Fetch all tools from MCP via tools/list. Caches result until invalidated.
+   * Returns empty array if MCP is unavailable.
+   */
+  async getTools(): Promise<McpToolDefinition[]> {
+    if (this.tools !== null) {
+      return this.tools;
+    }
+
+    if (!this.mcpBridge.isAvailable()) {
+      return [];
+    }
+
+    try {
+      const tools = await this.mcpBridge.listTools();
+      this.tools = tools;
+      return tools;
+    } catch {
+      // MCP unavailable or tools/list failed — return empty
+      return [];
+    }
+  }
+
+  /** Convert cached tools to Anthropic tool_use format */
+  toAnthropicFormat(tools: McpToolDefinition[]): AnthropicTool[] {
+    return tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema,
+    }));
+  }
+
+  /** Convert cached tools to OpenAI/Ollama function calling format */
+  toOpenAIFormat(tools: McpToolDefinition[]): OpenAIFunction[] {
+    return tools.map((t) => ({
+      type: "function" as const,
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema,
+      },
+    }));
+  }
+
+  /** Invalidate cache — call on MCP reconnect or tool changes */
+  invalidate(): void {
+    this.tools = null;
+  }
+}

package/extension/src/langgraph/vscode-tool-definitions.ts

@@ -0,0 +1,44 @@
+/**
+ * VS Code tool definitions — schema declarations for IDE-native tools.
+ * Extracted from vscode-tools.ts.
+ */
+import type { McpToolDefinition } from "./tool-registry";
+
+export const VSCODE_TOOL_DEFINITIONS: McpToolDefinition[] = [
+  {
+    name: "read_file",
+    description: "Read the content of a file. Returns the full text content.",
+    inputSchema: { type: "object", properties: { path: { type: "string", description: "File path relative to workspace root" }, start_line: { type: "number", description: "Optional start line (1-indexed)" }, end_line: { type: "number", description: "Optional end line (1-indexed)" } }, required: ["path"] },
+  },
+  {
+    name: "list_directory",
+    description: "List files and directories at the given path. Returns max 30 entries per page. Use offset to paginate.",
+    inputSchema: { type: "object", properties: { path: { type: "string", description: "Directory path relative to workspace root" }, recursive: { type: "boolean", description: "Whether to list recursively (default false, max depth 2)" }, limit: { type: "number", description: "Max entries per page (default 30)" }, offset: { type: "number", description: "Skip first N entries (default 0, for pagination)" } }, required: ["path"] },
+  },
+  {
+    name: "search_text",
+    description: "Search for text pattern in files. Returns matching lines with file paths and line numbers.",
+    inputSchema: { type: "object", properties: { pattern: { type: "string", description: "Text or regex pattern" }, include: { type: "string", description: "Glob pattern for files (e.g. '**/*.ts')" }, max_results: { type: "number", description: "Maximum results (default 20)" } }, required: ["pattern"] },
+  },
+  {
+    name: "write_file",
+    description: "Write content to a file. Creates if not exists, overwrites if it does.",
+    inputSchema: { type: "object", properties: { path: { type: "string", description: "File path relative to workspace root" }, content: { type: "string", description: "Content to write" } }, required: ["path", "content"] },
+  },
+  {
+    name: "get_diagnostics",
+    description: "Get compile errors, warnings, and lint issues for a file or workspace.",
+    inputSchema: { type: "object", properties: { path: { type: "string", description: "File path (optional — omit for all)" } } },
+  },
+  {
+    name: "get_open_files",
+    description: "Get the list of currently open files in the editor.",
+    inputSchema: { type: "object", properties: {} },
+  },
+];
+
+const VSCODE_TOOL_NAMES = new Set(VSCODE_TOOL_DEFINITIONS.map(t => t.name));
+
+export function isVscodeTool(name: string): boolean {
+  return VSCODE_TOOL_NAMES.has(name);
+}