sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/langgraph/nodes/workspace-file-ops.ts

@@ -0,0 +1,155 @@
+/**
+ * Workspace File Operations — extracted from BaseNode (KSA-242)
+ * Provides file read/write/export utilities for pipeline nodes.
+ */
+
+import { debugError } from "../../debug-logger";
+import type { McpBridge } from "../mcp-bridge";
+
+/** Extended timeout for DOCX export and draw.io PNG export (90s) */
+const EXPORT_TIMEOUT_MS = 90_000;
+
+/** Per-tool call timeout (60s) */
+const TOOL_CALL_TIMEOUT_MS = 60_000;
+
+export async function readWorkspaceFile(relativePath: string): Promise<string | null> {
+  try {
+    const vscode = require("vscode");
+    const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    if (!workspaceRoot) return null;
+    const path = require("path");
+    const fullPath = path.join(workspaceRoot, relativePath);
+    const uri = vscode.Uri.file(fullPath);
+    const bytes = await vscode.workspace.fs.readFile(uri);
+    return Buffer.from(bytes).toString("utf-8");
+  } catch {
+    return null;
+  }
+}
+
+export async function writeWorkspaceFile(
+  relativePath: string,
+  content: string,
+  mcpBridge: McpBridge,
+  preHookFn?: () => Promise<string[]>,
+  kbSearchFn?: (query: string) => Promise<string>,
+  fileHookFn?: (path: string) => Promise<void>
+): Promise<boolean> {
+  if (preHookFn) {
+    const instructions = await preHookFn();
+    if (relativePath.endsWith(".drawio") && kbSearchFn) {
+      for (const instruction of instructions) {
+        if (instruction.includes("drawio") && instruction.includes("mem_search")) {
+          await kbSearchFn("drawio procedure styles edges containers");
+        }
+      }
+    }
+  }
+
+  try {
+    const result = await mcpBridge.callTool("stream_write_file", {
+      file_path: relativePath, content, mode: "write",
+    }, TOOL_CALL_TIMEOUT_MS);
+    if (fileHookFn) await fileHookFn(relativePath);
+    return !result.includes("error");
+  } catch {
+    return await writeViaVscodeApi(relativePath, content);
+  }
+}
+
+async function writeViaVscodeApi(relativePath: string, content: string): Promise<boolean> {
+  try {
+    const vscode = require("vscode");
+    const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    if (!workspaceRoot) return false;
+    const path = require("path");
+    const fullPath = path.join(workspaceRoot, relativePath);
+    const uri = vscode.Uri.file(fullPath);
+    await vscode.workspace.fs.writeFile(uri, Buffer.from(content, "utf-8"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function appendWorkspaceFile(
+  relativePath: string, content: string, mcpBridge: McpBridge
+): Promise<boolean> {
+  try {
+    const result = await mcpBridge.callTool("stream_write_file", {
+      file_path: relativePath, content, mode: "append",
+    }, TOOL_CALL_TIMEOUT_MS);
+    return !result.includes("error");
+  } catch {
+    return false;
+  }
+}
+
+export async function exportDocx(
+  mdRelativePath: string, docxFileName: string, mcpBridge: McpBridge
+): Promise<string | null> {
+  try {
+    const workspaceRoot = getWorkspaceRoot();
+    if (!workspaceRoot) return null;
+    const path = require("path");
+    const absoluteMdPath = path.join(workspaceRoot, mdRelativePath);
+    const embeddedPath = absoluteMdPath.replace(/\.md$/, "-embedded.md");
+
+    await mcpBridge.callTool("execute_dynamic_tool", {
+      tool_name: "embed_images",
+      arguments: { file_path: absoluteMdPath, output_path: embeddedPath },
+    }, EXPORT_TIMEOUT_MS);
+
+    const result = await mcpBridge.callTool("execute_dynamic_tool", {
+      tool_name: "export_docx",
+      arguments: { file_path: embeddedPath, file_name: docxFileName },
+    }, EXPORT_TIMEOUT_MS);
+
+    await cleanupEmbeddedFile(embeddedPath);
+    return result || `${docxFileName}.docx`;
+  } catch (err) {
+    debugError(`[WorkspaceFileOps] DOCX export failed for ${mdRelativePath}`, err as Error);
+    return null;
+  }
+}
+
+export async function exportDrawioPng(
+  drawioRelativePath: string, mcpBridge: McpBridge
+): Promise<boolean> {
+  try {
+    const result = await mcpBridge.callTool("drawio_export_png", {
+      file_path: drawioRelativePath,
+    }, EXPORT_TIMEOUT_MS);
+    return !result.includes("error") && !result.includes("Error");
+  } catch (err) {
+    debugError(`[WorkspaceFileOps] draw.io export failed`, err as Error);
+    return false;
+  }
+}
+
+export function getWorkspaceRoot(): string | null {
+  try {
+    const vscode = require("vscode");
+    return vscode.workspace.workspaceFolders?.[0]?.uri.fsPath ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export async function readCodeIntelligence(moduleName?: string): Promise<string | null> {
+  const projectStructure = await readWorkspaceFile(
+    ".analysis/code-intelligence/project-structure.md"
+  );
+  if (!moduleName) return projectStructure;
+  const moduleAnalysis = await readWorkspaceFile(
+    `.analysis/code-intelligence/modules/${moduleName}.md`
+  );
+  return [projectStructure, moduleAnalysis].filter(Boolean).join("\n\n---\n\n");
+}
+
+async function cleanupEmbeddedFile(embeddedPath: string): Promise<void> {
+  try {
+    const vscode = require("vscode");
+    await vscode.workspace.fs.delete(vscode.Uri.file(embeddedPath));
+  } catch { /* ignore cleanup failure */ }
+}

package/extension/src/langgraph/providers/BaseLlmProvider.ts

@@ -0,0 +1,113 @@
+/**
+ * BaseLlmProvider — Abstract base class for LLM providers (Template Method pattern).
+ * Shared logic: availability check (ping with timeout), SSE/NDJSON stream reading.
+ * Subclasses override hook methods to customize behavior.
+ */
+import type { LlmProvider, LlmMessage, LlmOptions, LlmResponse, LlmProviderType } from "../llm-provider";
+import type { McpToolDefinition } from "../tool-registry";
+
+const DEFAULT_TIMEOUT_MS = 8000;
+
+export abstract class BaseLlmProvider implements LlmProvider {
+  abstract readonly type: LlmProviderType;
+
+  abstract chat(messages: LlmMessage[], options?: LlmOptions): Promise<string>;
+  abstract chatStream(messages: LlmMessage[], options?: LlmOptions): AsyncGenerator<string>;
+  abstract dispose(): void;
+
+  chatWithTools?(messages: LlmMessage[], tools: McpToolDefinition[], options?: LlmOptions): Promise<LlmResponse>;
+
+  /** Context window in tokens. Override in subclasses for accurate values. Default: 0 (unknown). */
+  protected contextWindowTokens = 0;
+
+  /** Get context window size in tokens. Returns 0 if unknown (no budget limit applied). */
+  getContextWindow(): number {
+    return this.contextWindowTokens;
+  }
+
+  /**
+   * Template Method for availability check.
+   * Subclasses override `getHealthCheckUrl()` and `isConfigured()`.
+   */
+  async isAvailable(): Promise<boolean> {
+    if (!await this.isConfigured()) return false;
+    return this.pingEndpoint();
+  }
+
+  /** Override: return true if provider has minimum config (key or URL) */
+  protected abstract isConfigured(): Promise<boolean>;
+
+  /** Override: return the URL to ping for health check */
+  protected abstract getHealthCheckUrl(): string;
+
+  /** Override: return HTTP method + headers + body for health check (default GET) */
+  protected getHealthCheckRequest(): { method: string; headers?: Record<string, string>; body?: string } {
+    return { method: "GET" };
+  }
+
+  /** Override: determine if response status means "available" */
+  protected isHealthyStatus(status: number): boolean {
+    return status >= 200 && status < 500;
+  }
+
+  /** Shared: ping endpoint with timeout */
+  private async pingEndpoint(): Promise<boolean> {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+    try {
+      const { method, headers, body } = this.getHealthCheckRequest();
+      const response = await fetch(this.getHealthCheckUrl(), {
+        method, headers, body, signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      return this.isHealthyStatus(response.status);
+    } catch {
+      clearTimeout(timeout);
+      return false;
+    }
+  }
+
+  /** Shared utility: read SSE/NDJSON stream */
+  protected async *readStream(
+    response: Response,
+    extractToken: (parsed: any) => string | null
+  ): AsyncGenerator<string> {
+    if (!response.body) throw new Error("No response body for streaming");
+    const reader = (response.body as any).getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          const data = trimmed.startsWith("data: ") ? trimmed.slice(6) : trimmed;
+          if (data === "[DONE]") return;
+          try {
+            const parsed = JSON.parse(data);
+            const token = extractToken(parsed);
+            if (token) yield token;
+          } catch { /* skip malformed */ }
+        }
+      }
+      // Flush remaining buffer
+      if (buffer.trim()) {
+        try {
+          const data = buffer.trim().startsWith("data: ") ? buffer.trim().slice(6) : buffer.trim();
+          if (data !== "[DONE]") {
+            const parsed = JSON.parse(data);
+            const token = extractToken(parsed);
+            if (token) yield token;
+          }
+        } catch { /* ignore */ }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}

package/extension/src/langgraph/providers/anthropic-adapter.ts

@@ -0,0 +1,165 @@
+// AnthropicAdapter --- KSA-231 --- Maps between LlmMessage and Kiro API format
+import type { LlmMessage, LlmOptions, LlmResponse, LlmToolCall } from "../llm-provider";
+import type { McpToolDefinition } from "../tool-registry";
+
+
+/** Default local kiro-ts gateway port (kiroSdlc.mcpServerPort default). */
+const DEFAULT_GATEWAY_PORT = 9181;
+
+
+export interface KiroRequestBody {
+  model: string;
+  max_tokens: number;
+  messages: Array<{ role: string; content: string | any[] }>;
+  system?: string;
+  stream?: boolean;
+  temperature?: number;
+  tools?: Array<{ name: string; description: string; input_schema: any }>;
+}
+
+
+export class AnthropicAdapter {
+  private readonly defaultModel: string;
+  private readonly defaultMaxTokens: number;
+
+  constructor(defaultModel = "", defaultMaxTokens = 4096) {
+    this.defaultModel = defaultModel;
+    this.defaultMaxTokens = defaultMaxTokens;
+  }
+
+  buildRequestBody(
+    messages: LlmMessage[],
+    options?: LlmOptions,
+    tools?: McpToolDefinition[]
+  ): KiroRequestBody {
+    const { systemPrompt, userMessages } = this.splitMessages(messages);
+
+    const body: KiroRequestBody = {
+      model: options?.model || this.defaultModel,
+      max_tokens: options?.maxTokens || this.defaultMaxTokens,
+      messages: this.formatMessages(userMessages),
+    };
+
+    if (systemPrompt) {
+      body.system = systemPrompt;
+    }
+
+    if (options?.temperature !== undefined) {
+      body.temperature = options.temperature;
+    }
+
+    if (tools && tools.length > 0) {
+      body.tools = tools.map(t => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.inputSchema,
+      }));
+    }
+
+    return body;
+  }
+
+  buildRequestHeaders(accessToken: string, modelId: string): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Model-Id": modelId,
+      "Accept": "text/event-stream",
+    };
+  }
+
+  buildNonStreamHeaders(accessToken: string, modelId: string): Record<string, string> {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      "X-Model-Id": modelId,
+    };
+  }
+
+  parseNonStreamResponse(json: any): LlmResponse {
+    if (!json.content || !Array.isArray(json.content)) {
+      return { type: "text", text: "" };
+    }
+
+    // Check for tool_use blocks
+    const toolUseBlocks = json.content.filter((block: any) => block.type === "tool_use");
+    if (toolUseBlocks.length > 0) {
+      const toolCalls: LlmToolCall[] = toolUseBlocks.map((block: any) => ({
+        id: block.id,
+        name: block.name,
+        arguments: block.input || {},
+      }));
+      return { type: "tool_use", toolCalls };
+    }
+
+    // Text response — concatenate all text blocks
+    const text = json.content
+      .filter((block: any) => block.type === "text")
+      .map((block: any) => block.text || "")
+      .join("");
+
+    return { type: "text", text };
+  }
+
+  getEndpointUrl(portOrRegion?: number | string): string {
+    const port = typeof portOrRegion === "number" ? portOrRegion : DEFAULT_GATEWAY_PORT;
+    return `http://127.0.0.1:${port}/v1/messages`;
+  }
+
+  getModelsEndpointUrl(port: number = DEFAULT_GATEWAY_PORT): string {
+    return `http://127.0.0.1:${port}/v1/models`;
+  }
+
+
+  private splitMessages(messages: LlmMessage[]): {
+    systemPrompt: string | undefined;
+    userMessages: LlmMessage[];
+  } {
+    const systemMsgs = messages.filter(m => m.role === "system");
+    const userMessages = messages.filter(m => m.role !== "system");
+    const systemPrompt = systemMsgs.length > 0
+      ? systemMsgs.map(m => m.content).join("\n\n")
+      : undefined;
+    return { systemPrompt, userMessages };
+  }
+
+  private formatMessages(messages: LlmMessage[]): Array<{ role: string; content: string | any[] }> {
+    const formatted: Array<{ role: string; content: string | any[] }> = [];
+
+    for (const msg of messages) {
+      if (msg.role === "tool") {
+        // Anthropic expects tool results wrapped in a user message
+        formatted.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: msg.toolCallId || "unknown",
+            content: msg.content,
+          }],
+        });
+      } else if (msg.role === "assistant") {
+        // Check if this is a tool_use assistant message (JSON array of tool_use blocks)
+        const toolUseBlocks = this.tryParseToolUseBlocks(msg.content);
+        if (toolUseBlocks) {
+          formatted.push({ role: "assistant", content: toolUseBlocks });
+        } else {
+          formatted.push({ role: "assistant", content: msg.content });
+        }
+      } else {
+        formatted.push({ role: "user", content: msg.content });
+      }
+    }
+
+    return formatted;
+  }
+
+  private tryParseToolUseBlocks(content: string): any[] | null {
+    try {
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed) && parsed.length > 0 && parsed[0]?.type === "tool_use") {
+        return parsed;
+      }
+    } catch { /* not JSON — regular text content */ }
+    return null;
+  }
+}

package/extension/src/langgraph/providers/anthropic-helpers.ts

@@ -0,0 +1,26 @@
+/**
+ * Anthropic provider helpers — message formatting.
+ * Extracted from anthropic-provider.ts.
+ */
+import type { LlmMessage } from "../llm-provider";
+
+export function splitMessages(messages: LlmMessage[]): { systemPrompt: string | undefined; userMessages: LlmMessage[] } {
+  const systemMsgs = messages.filter(m => m.role === "system");
+  const userMessages = messages.filter(m => m.role !== "system");
+  const systemPrompt = systemMsgs.length > 0 ? systemMsgs.map(m => m.content).join("\n\n") : undefined;
+  return { systemPrompt, userMessages };
+}
+
+export function formatMessagesForTools(messages: LlmMessage[]): any[] {
+  const formatted: any[] = [];
+  for (const msg of messages) {
+    if (msg.role === "tool") {
+      formatted.push({ role: "user", content: [{ type: "tool_result", tool_use_id: msg.toolCallId || "unknown", content: msg.content }] });
+    } else if (msg.role === "assistant") {
+      formatted.push({ role: "assistant", content: msg.content });
+    } else {
+      formatted.push({ role: "user", content: msg.content });
+    }
+  }
+  return formatted;
+}

package/extension/src/langgraph/providers/anthropic-provider.ts

@@ -0,0 +1,142 @@
+/**
+ * AnthropicProvider — KSA-210. LLM provider backed by Anthropic Messages API.
+ * Extends BaseLlmProvider for shared availability check and streaming.
+ */
+import type { LlmMessage, LlmOptions, LlmResponse, LlmToolCall } from "../llm-provider";
+import type { McpToolDefinition } from "../tool-registry";
+import { BaseLlmProvider } from "./BaseLlmProvider";
+import { splitMessages, formatMessagesForTools } from "./anthropic-helpers";
+
+export const ANTHROPIC_SECRET_KEY = "kiroSdlc.anthropicApiKey";
+const DEFAULT_MODEL = "claude-sonnet-4-latest";
+const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_BASE_URL = "https://api.anthropic.com";
+
+export class AnthropicProvider extends BaseLlmProvider {
+  readonly type = "anthropic" as const;
+  private client: any = null;
+  private readonly getApiKey: () => Promise<string | undefined>;
+  private readonly baseUrl: string;
+
+  constructor(getApiKey: () => Promise<string | undefined>, baseUrl?: string) {
+    super();
+    this.getApiKey = getApiKey;
+    this.baseUrl = (baseUrl || DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.contextWindowTokens = 200000; // Claude models have 200K context
+  }
+
+  async chat(messages: LlmMessage[], options?: LlmOptions): Promise<string> {
+    const client = await this.ensureClient();
+    const { systemPrompt, userMessages } = splitMessages(messages);
+    const params = this.buildParams(userMessages, options, systemPrompt, false);
+    const response = await client.messages.create(params);
+    return this.extractTextContent(response);
+  }
+
+  async *chatStream(messages: LlmMessage[], options?: LlmOptions): AsyncGenerator<string> {
+    const client = await this.ensureClient();
+    const { systemPrompt, userMessages } = splitMessages(messages);
+    const params = this.buildParams(userMessages, options, systemPrompt, true);
+    const stream = client.messages.stream(params);
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta?.text) {
+        yield event.delta.text;
+      }
+    }
+  }
+
+  async chatWithTools(messages: LlmMessage[], tools: McpToolDefinition[], options?: LlmOptions): Promise<LlmResponse> {
+    const client = await this.ensureClient();
+    const { systemPrompt, userMessages } = splitMessages(messages);
+    const anthropicTools = tools.map(t => ({
+      name: t.name, description: t.description, input_schema: t.inputSchema,
+    }));
+    const formattedMessages = formatMessagesForTools(userMessages);
+    const params: Record<string, unknown> = {
+      model: options?.model || DEFAULT_MODEL,
+      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS,
+      messages: formattedMessages, tools: anthropicTools, stream: false,
+    };
+    if (systemPrompt) { params.system = systemPrompt; }
+    if (options?.temperature !== undefined) { params.temperature = options.temperature; }
+    const response = await client.messages.create(params);
+    const content = Array.isArray(response?.content) ? response.content : [];
+    const toolUseBlocks = content.filter((b: any) => b.type === "tool_use");
+    if (toolUseBlocks.length > 0) {
+      const toolCalls: LlmToolCall[] = toolUseBlocks.map((b: any) => ({
+        id: b.id, name: b.name, arguments: b.input || {},
+      }));
+      return { type: "tool_use", toolCalls };
+    }
+    return { type: "text", text: this.extractTextContent(response) };
+  }
+
+  dispose(): void { this.client = null; }
+
+  // --- Template Method hooks ---
+
+  protected async isConfigured(): Promise<boolean> {
+    const key = await this.getApiKey();
+    return !!(key || this.baseUrl !== DEFAULT_BASE_URL);
+  }
+
+  protected getHealthCheckUrl(): string {
+    return `${this.baseUrl}/v1/messages`;
+  }
+
+  protected getHealthCheckRequest() {
+    return {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": "health-check",
+        "anthropic-version": "2023-06-01",
+      },
+      body: JSON.stringify({
+        model: DEFAULT_MODEL, max_tokens: 1,
+        messages: [{ role: "user", content: "ping" }],
+      }),
+    };
+  }
+
+  protected isHealthyStatus(status: number): boolean {
+    return status < 500;
+  }
+
+  // --- Private helpers ---
+
+  private buildParams(
+    userMessages: LlmMessage[], options: LlmOptions | undefined,
+    systemPrompt: string | undefined, stream: boolean
+  ): Record<string, unknown> {
+    const params: Record<string, unknown> = {
+      model: options?.model || DEFAULT_MODEL,
+      max_tokens: options?.maxTokens || DEFAULT_MAX_TOKENS,
+      messages: userMessages.map(m => ({ role: m.role, content: m.content })),
+      stream,
+    };
+    if (systemPrompt) { params.system = systemPrompt; }
+    if (options?.temperature !== undefined) { params.temperature = options.temperature; }
+    return params;
+  }
+
+  private extractTextContent(response: any): string {
+    const content = Array.isArray(response?.content) ? response.content : [];
+    return content.filter((b: any) => b.type === "text").map((b: any) => b.text || "").join("");
+  }
+
+  private async ensureClient(): Promise<any> {
+    if (this.client) { return this.client; }
+    const apiKey = await this.getApiKey();
+    if (!apiKey && this.baseUrl === DEFAULT_BASE_URL) {
+      throw new Error("Anthropic API key not configured.");
+    }
+    const { default: Anthropic } = await import("@anthropic-ai/sdk");
+    const opts: Record<string, any> = {};
+    if (apiKey) { opts.apiKey = apiKey; }
+    if (this.baseUrl !== DEFAULT_BASE_URL) { opts.baseURL = this.baseUrl; }
+    if (!apiKey && this.baseUrl !== DEFAULT_BASE_URL) { opts.apiKey = "not-needed"; }
+    this.client = new Anthropic(opts);
+    return this.client;
+  }
+}