sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/addon-download-helpers.ts

@@ -0,0 +1,135 @@
+/**
+ * Download helpers for native addon management.
+ * Extracted from native-addon-manager.ts for file size compliance.
+ */
+
+import * as vscode from "vscode";
+import * as fs from "fs";
+import * as https from "https";
+import * as http from "http";
+import * as crypto from "crypto";
+
+/**
+ * Download a file with redirect support, progress reporting, and cancellation.
+ */
+export function downloadFile(
+  url: string,
+  target: string,
+  expectedSize: number,
+  progress: vscode.Progress<{ message?: string; increment?: number }>,
+  token: vscode.CancellationToken,
+  proxyUrl: string | undefined,
+  outputChannel: vscode.OutputChannel,
+  maxRedirects = 10
+): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (maxRedirects <= 0) {
+      reject(new Error("Too many redirects"));
+      return;
+    }
+    if (token.isCancellationRequested) {
+      reject(new Error("Cancelled"));
+      return;
+    }
+    const parsedUrl = new URL(url);
+    const client = parsedUrl.protocol === "https:" ? https : http;
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port,
+      path: parsedUrl.pathname + parsedUrl.search,
+      timeout: 60000,
+      headers: { "User-Agent": "kiro-sdlc-agents/1.0" },
+    } as https.RequestOptions;
+
+    if (proxyUrl) {
+      outputChannel.appendLine(`[NativeAddon] Using proxy: ${proxyUrl}`);
+    }
+
+    const req = client.get(options, (res) => {
+      const status = res.statusCode ?? 0;
+      if (status >= 300 && status < 400 && res.headers.location) {
+        res.resume();
+        downloadFile(res.headers.location, target, expectedSize, progress, token, proxyUrl, outputChannel, maxRedirects - 1)
+          .then(resolve).catch(reject);
+        return;
+      }
+      if (status !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${status} from ${parsedUrl.hostname}`));
+        return;
+      }
+      handleSuccessResponse(res, target, expectedSize, progress, token, req, reject, resolve);
+    });
+
+    req.on("timeout", () => { req.destroy(); reject(new Error("Download timed out (60s)")); });
+    req.on("error", (err) => {
+      if (fs.existsSync(target)) { try { fs.unlinkSync(target); } catch { } }
+      reject(err);
+    });
+  });
+}
+
+function handleSuccessResponse(
+  res: http.IncomingMessage,
+  target: string,
+  expectedSize: number,
+  progress: vscode.Progress<{ message?: string; increment?: number }>,
+  token: vscode.CancellationToken,
+  req: http.ClientRequest,
+  reject: (reason?: any) => void,
+  resolve: () => void
+): void {
+  const totalBytes = parseInt(res.headers["content-length"] || String(expectedSize), 10);
+  let downloadedBytes = 0;
+  let lastReportedPercent = 0;
+  const file = fs.createWriteStream(target);
+
+  res.on("data", (chunk) => {
+    downloadedBytes += chunk.length;
+    const percent = Math.floor((downloadedBytes / totalBytes) * 100);
+    if (percent > lastReportedPercent) {
+      const mb = (downloadedBytes / 1024 / 1024).toFixed(1);
+      const totalMb = (totalBytes / 1024 / 1024).toFixed(1);
+      progress.report({ message: `${mb} MB / ${totalMb} MB (${percent}%)`, increment: percent - lastReportedPercent });
+      lastReportedPercent = percent;
+    }
+  });
+
+  res.pipe(file);
+  file.on("finish", () => { file.close(); resolve(); });
+  file.on("error", (err) => {
+    file.close();
+    if (fs.existsSync(target)) { fs.unlinkSync(target); }
+    reject(err);
+  });
+  token.onCancellationRequested(() => {
+    req.destroy(); file.close();
+    if (fs.existsSync(target)) { fs.unlinkSync(target); }
+    reject(new Error("Cancelled"));
+  });
+}
+
+/**
+ * Compute SHA-256 hash of a file.
+ */
+export function computeSha256(filePath: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+}
+
+/**
+ * Get proxy URL from VS Code config or environment.
+ */
+export function getProxyUrl(): string | undefined {
+  try {
+    const config = vscode.workspace.getConfiguration("http");
+    return config.get<string>("proxy") || process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
+  } catch {
+    return process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
+  }
+}

package/extension/src/ai-context-commands.ts

@@ -0,0 +1,97 @@
+/**
+ * AI Context Commands — KSA-177
+ * Commands to get AI context for symbol at cursor and copy to clipboard.
+ * Commands: kiroSdlc.getAIContext, kiroSdlc.getEditContext
+ */
+
+import * as vscode from "vscode";
+import { McpServerManager } from "./mcp-server-manager";
+
+/**
+ * Register AI context commands.
+ */
+export function registerAIContextCommands(
+  context: vscode.ExtensionContext,
+  mcpManager: McpServerManager
+): void {
+  context.subscriptions.push(
+    vscode.commands.registerCommand("kiroSdlc.getAIContext", () =>
+      getContextForCursor(mcpManager, "get_ai_context")
+    ),
+    vscode.commands.registerCommand("kiroSdlc.getEditContext", () =>
+      getContextForCursor(mcpManager, "get_edit_context")
+    )
+  );
+}
+
+async function getContextForCursor(mcpManager: McpServerManager, toolName: string): Promise<void> {
+  const editor = vscode.window.activeTextEditor;
+  if (!editor) {
+    vscode.window.showWarningMessage("No active editor. Open a file first.");
+    return;
+  }
+
+  const symbol = getSymbolAtCursor(editor);
+  const file = vscode.workspace.asRelativePath(editor.document.uri);
+  const line = editor.selection.active.line + 1;
+
+  if (!symbol) {
+    vscode.window.showWarningMessage("No symbol found at cursor position.");
+    return;
+  }
+
+  try {
+    const raw = await mcpManager.invokeTool(toolName, { symbol, file, line });
+    const contextText = formatContext(raw, symbol, toolName);
+    await vscode.env.clipboard.writeText(contextText);
+    vscode.window.showInformationMessage(`Context for "${symbol}" copied to clipboard.`);
+  } catch (err) {
+    vscode.window.showErrorMessage(`Failed to get context: ${(err as Error).message}`);
+  }
+}
+
+function getSymbolAtCursor(editor: vscode.TextEditor): string | undefined {
+  const position = editor.selection.active;
+  const wordRange = editor.document.getWordRangeAtPosition(position);
+  if (!wordRange) { return undefined; }
+  return editor.document.getText(wordRange);
+}
+
+function formatContext(raw: string, symbol: string, toolName: string): string {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "string") { return parsed; }
+
+    const sections: string[] = [];
+    const label = toolName === "get_ai_context" ? "AI" : "Edit";
+    sections.push(`# ${label} Context: ${symbol}\n`);
+
+    if (parsed.definition) {
+      sections.push(`## Definition\n\`\`\`\n${parsed.definition}\n\`\`\`\n`);
+    }
+    if (parsed.documentation) {
+      sections.push(`## Documentation\n${parsed.documentation}\n`);
+    }
+    if (parsed.usages && parsed.usages.length > 0) {
+      sections.push(`## Usages (${parsed.usages.length})`);
+      for (const usage of parsed.usages.slice(0, 10)) {
+        sections.push(`- ${usage.file}:${usage.line} — ${usage.context || ""}`);
+      }
+      sections.push("");
+    }
+    if (parsed.relatedSymbols && parsed.relatedSymbols.length > 0) {
+      sections.push(`## Related Symbols`);
+      for (const rel of parsed.relatedSymbols.slice(0, 10)) {
+        sections.push(`- ${rel.name} (${rel.kind}) — ${rel.file || ""}`);
+      }
+      sections.push("");
+    }
+    if (parsed.context) {
+      sections.push(`## Context\n${parsed.context}\n`);
+    }
+
+    return sections.join("\n") || raw;
+  } catch {
+    return raw;
+  }
+}

package/extension/src/anthropic/__tests__/converter.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect } from 'vitest';
+import { convertResponseToSSEEvents, validateToolUseId, extractToolUseIds } from '../converter';
+import { KiroQResponse, ContentBlockStartEvent } from '../types';
+
+describe('convertResponseToSSEEvents', () => {
+  // TC-1: Single tool_use - ID preserved in SSE stream
+  it('TC-1: preserves tool_use_id in SSE stream', () => {
+    const response: KiroQResponse = {
+      id: 'msg_123',
+      type: 'message',
+      role: 'assistant',
+      content: [{
+        type: 'tool_use',
+        id: 'tooluse_490CAbc',
+        name: 'readFile',
+        input: { path: '/src/main.ts' },
+      }],
+      stop_reason: 'tool_use',
+    };
+
+    const events = convertResponseToSSEEvents(response);
+    const startEvent = events.find(e => e.type === 'content_block_start') as ContentBlockStartEvent;
+
+    expect(startEvent).toBeDefined();
+    expect(startEvent.content_block.id).toBe('tooluse_490CAbc');
+    expect(startEvent.content_block.name).toBe('readFile');
+    expect(startEvent.content_block.type).toBe('tool_use');
+  });
+
+  // TC-5: Multiple tool_use blocks - all IDs preserved independently
+  it('TC-5: preserves multiple tool_use_ids independently', () => {
+    const response: KiroQResponse = {
+      id: 'msg_456',
+      type: 'message',
+      role: 'assistant',
+      content: [
+        { type: 'tool_use', id: 'tooluse_AAA', name: 'readFile', input: { path: '/a' } },
+        { type: 'tool_use', id: 'tooluse_BBB', name: 'grep_search', input: { query: 'x' } },
+        { type: 'tool_use', id: 'tooluse_CCC', name: 'writeFile', input: { path: '/b' } },
+      ],
+      stop_reason: 'tool_use',
+    };
+
+    const events = convertResponseToSSEEvents(response);
+    const startEvents = events.filter(
+      (e): e is ContentBlockStartEvent => e.type === 'content_block_start'
+    );
+
+    expect(startEvents).toHaveLength(3);
+    expect(startEvents[0].content_block.id).toBe('tooluse_AAA');
+    expect(startEvents[1].content_block.id).toBe('tooluse_BBB');
+    expect(startEvents[2].content_block.id).toBe('tooluse_CCC');
+  });
+
+  // TC-10: Regression guard - no ID generation, exact passthrough
+  it('TC-10: no call to ID generation - exact passthrough regression guard', () => {
+    const inputId = 'tooluse_ExactMatch123';
+    const response: KiroQResponse = {
+      id: 'msg_789',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'tool_use', id: inputId, name: 'test', input: {} }],
+      stop_reason: 'tool_use',
+    };
+
+    const events = convertResponseToSSEEvents(response);
+    const ids = extractToolUseIds(response);
+
+    // Both extraction methods return the exact same input ID
+    expect(ids).toEqual([inputId]);
+    const startEvent = events.find(
+      (e): e is ContentBlockStartEvent => e.type === 'content_block_start'
+    ) as ContentBlockStartEvent;
+    expect(startEvent.content_block.id).toBe(inputId);
+  });
+
+  it('handles text blocks without id field', () => {
+    const response: KiroQResponse = {
+      id: 'msg_text',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Hello world' }],
+      stop_reason: 'end_turn',
+    };
+
+    const events = convertResponseToSSEEvents(response);
+    const startEvent = events.find(
+      (e): e is ContentBlockStartEvent => e.type === 'content_block_start'
+    ) as ContentBlockStartEvent;
+
+    expect(startEvent.content_block.type).toBe('text');
+    expect(startEvent.content_block.id).toBeUndefined();
+  });
+
+  it('produces correct event sequence for tool_use block', () => {
+    const response: KiroQResponse = {
+      id: 'msg_seq',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'tool_use', id: 'tooluse_SEQ1', name: 'readFile', input: { path: '/x' } }],
+      stop_reason: 'tool_use',
+    };
+
+    const events = convertResponseToSSEEvents(response);
+    const types = events.map(e => e.type);
+
+    expect(types).toEqual([
+      'content_block_start',
+      'content_block_delta',
+      'content_block_stop',
+      'message_stop',
+    ]);
+  });
+
+  it('streams tool input as JSON delta', () => {
+    const input = { path: '/src/main.ts', encoding: 'utf-8' };
+    const response: KiroQResponse = {
+      id: 'msg_delta',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'tool_use', id: 'tooluse_DELTA', name: 'readFile', input }],
+      stop_reason: 'tool_use',
+    };
+
+    const events = convertResponseToSSEEvents(response);
+    const deltaEvent = events.find(e => e.type === 'content_block_delta');
+
+    expect(deltaEvent).toBeDefined();
+    if (deltaEvent && deltaEvent.type === 'content_block_delta') {
+      expect(deltaEvent.delta.type).toBe('input_json_delta');
+      expect(deltaEvent.delta.partial_json).toBe(JSON.stringify(input));
+    }
+  });
+});
+
+describe('extractToolUseIds', () => {
+  it('returns empty array for text-only response', () => {
+    const response: KiroQResponse = {
+      id: 'msg_no_tools',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'text', text: 'No tools needed' }],
+      stop_reason: 'end_turn',
+    };
+
+    expect(extractToolUseIds(response)).toEqual([]);
+  });
+
+  it('returns all tool_use ids in order', () => {
+    const response: KiroQResponse = {
+      id: 'msg_multi',
+      type: 'message',
+      role: 'assistant',
+      content: [
+        { type: 'tool_use', id: 'tooluse_First', name: 'a', input: {} },
+        { type: 'text', text: 'some text' },
+        { type: 'tool_use', id: 'tooluse_Second', name: 'b', input: {} },
+      ],
+      stop_reason: 'tool_use',
+    };
+
+    expect(extractToolUseIds(response)).toEqual(['tooluse_First', 'tooluse_Second']);
+  });
+});
+
+describe('validateToolUseId', () => {
+  // TC-7: Rejects empty string
+  it('TC-7: rejects empty string', () => {
+    expect(validateToolUseId('')).toBe(false);
+  });
+
+  // TC-8: Rejects undefined/null/non-string
+  it('TC-8: rejects undefined', () => {
+    expect(validateToolUseId(undefined)).toBe(false);
+  });
+
+  it('TC-8: rejects null', () => {
+    expect(validateToolUseId(null)).toBe(false);
+  });
+
+  it('TC-8: rejects number', () => {
+    expect(validateToolUseId(12345)).toBe(false);
+  });
+
+  it('rejects string without tooluse_ prefix', () => {
+    expect(validateToolUseId('abc123')).toBe(false);
+  });
+
+  it('rejects string with special characters', () => {
+    expect(validateToolUseId('tooluse_abc-def')).toBe(false);
+    expect(validateToolUseId('tooluse_abc_def')).toBe(false);
+    expect(validateToolUseId('tooluse_abc.def')).toBe(false);
+  });
+
+  it('accepts valid tooluse_[A-Za-z0-9]+ format', () => {
+    expect(validateToolUseId('tooluse_ABC123')).toBe(true);
+    expect(validateToolUseId('tooluse_a')).toBe(true);
+    expect(validateToolUseId('tooluse_490CAbc')).toBe(true);
+    expect(validateToolUseId('tooluse_ExactMatch123')).toBe(true);
+  });
+});

package/extension/src/anthropic/__tests__/handlers.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { createChatCompletionsHandler } from '../handlers';
+import { ConversationHistory } from '../../history/conversation';
+import { KiroQResponse, ContinuationRequest } from '../types';
+
+function createTestApp(
+  history: ConversationHistory,
+  mockForward: (req: ContinuationRequest) => Promise<KiroQResponse>,
+) {
+  const app = express();
+  app.use(express.json());
+  app.post('/chat/completions', createChatCompletionsHandler(history, mockForward));
+  return app;
+}
+
+describe('handleChatCompletions', () => {
+  let history: ConversationHistory;
+
+  beforeEach(() => {
+    history = new ConversationHistory();
+  });
+
+  // TC-3: Continuation matches history
+  it('TC-3: continuation request matches stored tool_use_id in history', async () => {
+    // Pre-populate history with a tool_use
+    const initialResponse: KiroQResponse = {
+      id: 'msg_init',
+      type: 'message',
+      role: 'assistant',
+      content: [{
+        type: 'tool_use',
+        id: 'tooluse_ABC123',
+        name: 'readFile',
+        input: { path: '/src/main.ts' },
+      }],
+      stop_reason: 'tool_use',
+    };
+    history.addAssistantMessage(initialResponse);
+
+    // Mock: next response after tool result is text
+    const nextResponse: KiroQResponse = {
+      id: 'msg_next',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Analysis complete.' }],
+      stop_reason: 'end_turn',
+    };
+    const mockForward = vi.fn().mockResolvedValue(nextResponse);
+
+    const app = createTestApp(history, mockForward);
+
+    const res = await request(app)
+      .post('/chat/completions')
+      .send({
+        messages: [],
+        toolResult: {
+          toolUseId: 'tooluse_ABC123',
+          content: 'file contents here',
+          isError: false,
+        },
+      })
+      .expect(200);
+
+    // Should stream SSE response
+    expect(res.headers['content-type']).toContain('text/event-stream');
+    expect(res.text).toContain('message_stop');
+    expect(mockForward).toHaveBeenCalledTimes(1);
+  });
+
+  // TC-4: Full ReAct loop - no 400 error
+  it('TC-4: full ReAct loop completes without 400 error', async () => {
+    // Step 1: Initial request -> API returns tool_use
+    const toolUseResponse: KiroQResponse = {
+      id: 'msg_tool',
+      type: 'message',
+      role: 'assistant',
+      content: [{
+        type: 'tool_use',
+        id: 'tooluse_LoopTest',
+        name: 'readFile',
+        input: { path: '/test.ts' },
+      }],
+      stop_reason: 'tool_use',
+    };
+
+    // Step 2: After continuation -> API returns final text
+    const finalResponse: KiroQResponse = {
+      id: 'msg_final',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'text', text: 'Done analyzing.' }],
+      stop_reason: 'end_turn',
+    };
+
+    let callCount = 0;
+    const mockForward = vi.fn().mockImplementation(() => {
+      callCount++;
+      return Promise.resolve(callCount === 1 ? toolUseResponse : finalResponse);
+    });
+
+    const app = createTestApp(history, mockForward);
+
+    // Initial request
+    const res1 = await request(app)
+      .post('/chat/completions')
+      .send({ messages: [{ role: 'user', content: 'Read test.ts' }] })
+      .expect(200);
+
+    expect(res1.text).toContain('tooluse_LoopTest');
+    expect(res1.text).toContain('content_block_start');
+
+    // Continuation with tool result (should NOT 400)
+    const res2 = await request(app)
+      .post('/chat/completions')
+      .send({
+        messages: [],
+        toolResult: {
+          toolUseId: 'tooluse_LoopTest',
+          content: 'file content',
+          isError: false,
+        },
+      })
+      .expect(200);
+
+    expect(res2.text).toContain('message_stop');
+    expect(res2.text).toContain('text_delta');
+  });
+
+  // TC-6: Mismatch diagnostic - ID not found
+  it('TC-6: returns descriptive error when tool_use_id not found in history', async () => {
+    // Pre-populate with known ID
+    const response: KiroQResponse = {
+      id: 'msg_known',
+      type: 'message',
+      role: 'assistant',
+      content: [{
+        type: 'tool_use',
+        id: 'tooluse_KnownID',
+        name: 'readFile',
+        input: {},
+      }],
+      stop_reason: 'tool_use',
+    };
+    history.addAssistantMessage(response);
+
+    const mockForward = vi.fn();
+    const app = createTestApp(history, mockForward);
+
+    // Send continuation with WRONG ID
+    const res = await request(app)
+      .post('/chat/completions')
+      .send({
+        messages: [],
+        toolResult: {
+          toolUseId: 'tooluse_WRONGID',
+          content: 'some result',
+          isError: false,
+        },
+      })
+      .expect(400);
+
+    // Verify descriptive error (BR-8)
+    expect(res.body.error.type).toBe('tool_use_id_mismatch');
+    expect(res.body.error.message).toContain('tooluse_WRONGID');
+    expect(res.body.error.message).toContain('not found in conversation history');
+    expect(res.body.error.received_id).toBe('tooluse_WRONGID');
+    expect(res.body.error.available_ids).toContain('tooluse_KnownID');
+    expect(res.body.error.turn_number).toBeGreaterThan(0);
+
+    // forwardToKiroQ should NOT be called on mismatch
+    expect(mockForward).not.toHaveBeenCalled();
+  });
+
+  // TC-6 extension: Empty history case
+  it('TC-6: returns empty available_ids when history has no tool_use entries', async () => {
+    const mockForward = vi.fn();
+    const app = createTestApp(history, mockForward);
+
+    const res = await request(app)
+      .post('/chat/completions')
+      .send({
+        messages: [],
+        toolResult: {
+          toolUseId: 'tooluse_Orphan',
+          content: 'result',
+          isError: false,
+        },
+      })
+      .expect(400);
+
+    expect(res.body.error.available_ids).toEqual([]);
+    expect(res.body.error.turn_number).toBe(0);
+  });
+
+  // Malformed API response (invalid tool_use_id from upstream)
+  it('returns 502 when API returns invalid tool_use_id', async () => {
+    const malformedResponse: KiroQResponse = {
+      id: 'msg_bad',
+      type: 'message',
+      role: 'assistant',
+      content: [{
+        type: 'tool_use',
+        id: '', // Empty - invalid (BR-3)
+        name: 'readFile',
+        input: {},
+      }],
+      stop_reason: 'tool_use',
+    };
+    const mockForward = vi.fn().mockResolvedValue(malformedResponse);
+    const app = createTestApp(history, mockForward);
+
+    const res = await request(app)
+      .post('/chat/completions')
+      .send({ messages: [{ role: 'user', content: 'test' }] })
+      .expect(502);
+
+    expect(res.body.error.type).toBe('malformed_api_response');
+  });
+
+  // Upstream error handling
+  it('returns 502 when Kiro Q API call fails', async () => {
+    const mockForward = vi.fn().mockRejectedValue(new Error('Network timeout'));
+    const app = createTestApp(history, mockForward);
+
+    const res = await request(app)
+      .post('/chat/completions')
+      .send({ messages: [{ role: 'user', content: 'test' }] })
+      .expect(502);
+
+    expect(res.body.error.type).toBe('upstream_error');
+  });
+
+  // SSE headers
+  it('sets correct SSE headers on success', async () => {
+    const response: KiroQResponse = {
+      id: 'msg_headers',
+      type: 'message',
+      role: 'assistant',
+      content: [{ type: 'text', text: 'hi' }],
+      stop_reason: 'end_turn',
+    };
+    const mockForward = vi.fn().mockResolvedValue(response);
+    const app = createTestApp(history, mockForward);
+
+    const res = await request(app)
+      .post('/chat/completions')
+      .send({ messages: [{ role: 'user', content: 'hello' }] })
+      .expect(200);
+
+    expect(res.headers['content-type']).toContain('text/event-stream');
+    expect(res.headers['cache-control']).toBe('no-cache');
+  });
+});