sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/connection/HealthChecker.ts

@@ -0,0 +1,45 @@
+/**
+ * HealthChecker — Periodic /health endpoint polling.
+ * Fires onHealthFail event when backend becomes unreachable.
+ */
+
+import { HttpClient } from "../proxy/HttpClient";
+
+export class HealthChecker {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private failListeners: Array<() => void> = [];
+
+  constructor(
+    private readonly httpClient: HttpClient,
+    public interval: number = 30000
+  ) {}
+
+  onHealthFail(listener: () => void): void {
+    this.failListeners.push(listener);
+  }
+
+  start(): void {
+    this.stop();
+    this.timer = setInterval(() => this.check(), this.interval);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+
+  async checkOnce(): Promise<boolean> {
+    return this.httpClient.healthCheck();
+  }
+
+  private async check(): Promise<void> {
+    const healthy = await this.httpClient.healthCheck();
+    if (!healthy) {
+      for (const listener of this.failListeners) {
+        listener();
+      }
+    }
+  }
+}

package/extension/src/converter/FileConverterService.ts

@@ -0,0 +1,62 @@
+/**
+ * Facade + Chain of Responsibility for file conversion.
+ * Tries each converter strategy in order until one succeeds.
+ */
+import * as fs from "fs";
+import { IFileConverter, ConversionResult } from "./IFileConverter";
+import { TextConverter } from "./TextConverter";
+import { RemoteConverter } from "./RemoteConverter";
+import { LocalFallbackConverter } from "./LocalFallbackConverter";
+
+const SIZE_LIMITS: Record<string, number> = {
+    pdf: 50 * 1024 * 1024,
+    png: 20 * 1024 * 1024, jpg: 20 * 1024 * 1024, jpeg: 20 * 1024 * 1024,
+    gif: 20 * 1024 * 1024, bmp: 20 * 1024 * 1024, webp: 20 * 1024 * 1024,
+    svg: 20 * 1024 * 1024, default: 50 * 1024 * 1024,
+};
+
+export class FileConverterService {
+    private readonly converters: IFileConverter[];
+
+    constructor() {
+        this.converters = [
+            new TextConverter(),
+            new RemoteConverter(),
+            new LocalFallbackConverter(),
+        ];
+    }
+
+    async convert(filePath: string, format: string, token?: string): Promise<ConversionResult> {
+        const startTime = Date.now();
+
+        // Step 1: Check file exists and get size
+        let fileSize: number;
+        try {
+            const stat = fs.statSync(filePath);
+            fileSize = stat.size;
+        } catch (err: any) {
+            return this.failure(`File not found or inaccessible: ${err.code || err.message}`, 0, startTime);
+        }
+
+        // Step 2: Check size limit
+        const limit = SIZE_LIMITS[format.toLowerCase()] ?? SIZE_LIMITS.default;
+        if (fileSize > limit) {
+            const limitMB = (limit / (1024 * 1024)).toFixed(0);
+            const fileMB = (fileSize / (1024 * 1024)).toFixed(1);
+            return this.failure(`Exceeds size limit: ${fileMB}MB > ${limitMB}MB limit for .${format}`, fileSize, startTime);
+        }
+
+        // Step 3: Try each converter in order — return first success
+        for (const converter of this.converters) {
+            if (!converter.canConvert(format)) { continue; }
+            const result = await converter.convert(filePath, format, token);
+            if (result.success) { return result; }
+        }
+
+        return this.failure("All converters failed", fileSize, startTime);
+    }
+
+    private failure(error: string, bytesProcessed: number, startTime: number): ConversionResult {
+        return { markdown: "", success: false, error, bytesProcessed, conversionTime: Date.now() - startTime };
+    }
+}

package/extension/src/converter/IFileConverter.ts

@@ -0,0 +1,15 @@
+/**
+ * Strategy interface for file conversion.
+ */
+export interface ConversionResult {
+    markdown: string;
+    success: boolean;
+    error: string | null;
+    bytesProcessed: number;
+    conversionTime: number;
+}
+
+export interface IFileConverter {
+    canConvert(format: string): boolean;
+    convert(filePath: string, format: string, token?: string): Promise<ConversionResult>;
+}

package/extension/src/converter/LocalFallbackConverter.ts

@@ -0,0 +1,89 @@
+/**
+ * Strategy: Local fallback using filetomarkdown package.
+ * Handles binary formats when remote conversion fails.
+ */
+import * as fs from "fs";
+import { IFileConverter, ConversionResult } from "./IFileConverter";
+
+const CONVERSION_TIMEOUT_MS = 30000;
+
+let filetomarkdownModule: any = null;
+let filetomarkdownLoadAttempted = false;
+
+export class LocalFallbackConverter implements IFileConverter {
+    canConvert(_format: string): boolean {
+        return true; // Fallback for any format
+    }
+
+    async convert(filePath: string, _format: string): Promise<ConversionResult> {
+        const startTime = Date.now();
+        const fileSize = fs.statSync(filePath).size;
+
+        const ftm = this.loadFileToMarkdown();
+        if (!ftm) {
+            return {
+                markdown: "",
+                success: false,
+                error: "filetomarkdown package unavailable — cannot convert binary formats. Install with: npm install filetomarkdown",
+                bytesProcessed: fileSize,
+                conversionTime: Date.now() - startTime,
+            };
+        }
+
+        try {
+            const markdown = await this.convertWithTimeout(ftm, filePath);
+            if (!markdown || markdown.trim().length === 0) {
+                return {
+                    markdown: "",
+                    success: false,
+                    error: "Conversion returned empty content",
+                    bytesProcessed: fileSize,
+                    conversionTime: Date.now() - startTime,
+                };
+            }
+            return { markdown, success: true, error: null, bytesProcessed: fileSize, conversionTime: Date.now() - startTime };
+        } catch (err: any) {
+            const isTimeout = err.message?.includes("timeout");
+            const error = isTimeout
+                ? `Conversion timeout: exceeded ${CONVERSION_TIMEOUT_MS / 1000}s limit`
+                : `Conversion failed: ${err.message}`;
+            return { markdown: "", success: false, error, bytesProcessed: fileSize, conversionTime: Date.now() - startTime };
+        }
+    }
+
+    private loadFileToMarkdown(): any {
+        if (filetomarkdownModule) { return filetomarkdownModule; }
+        if (filetomarkdownLoadAttempted) { return null; }
+        filetomarkdownLoadAttempted = true;
+        try {
+            filetomarkdownModule = require("filetomarkdown");
+            return filetomarkdownModule;
+        } catch { return null; }
+    }
+
+    private async convertWithTimeout(ftm: any, filePath: string): Promise<string> {
+        return new Promise<string>((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Conversion timeout: file took longer than ${CONVERSION_TIMEOUT_MS / 1000}s`));
+            }, CONVERSION_TIMEOUT_MS);
+
+            const promise = typeof ftm.convert === "function"
+                ? ftm.convert(filePath)
+                : typeof ftm.default === "function"
+                    ? ftm.default(filePath)
+                    : typeof ftm === "function"
+                        ? ftm(filePath)
+                        : Promise.reject(new Error("filetomarkdown: no convert function found"));
+
+            Promise.resolve(promise)
+                .then((result: any) => {
+                    clearTimeout(timer);
+                    if (typeof result === "string") { resolve(result); }
+                    else if (result && typeof result.content === "string") { resolve(result.content); }
+                    else if (result && typeof result.markdown === "string") { resolve(result.markdown); }
+                    else { resolve(String(result || "")); }
+                })
+                .catch((err: any) => { clearTimeout(timer); reject(err); });
+        });
+    }
+}

package/extension/src/converter/RemoteConverter.ts

@@ -0,0 +1,86 @@
+/**
+ * Strategy: Converts files via the remote backend MCP endpoint.
+ * Handles all non-text formats as first attempt.
+ */
+import * as fs from "fs";
+import * as http from "http";
+import * as vscode from "vscode";
+import { IFileConverter, ConversionResult } from "./IFileConverter";
+
+export class RemoteConverter implements IFileConverter {
+    canConvert(_format: string): boolean {
+        return true; // Attempts any format remotely
+    }
+
+    async convert(filePath: string, _format: string, token?: string): Promise<ConversionResult> {
+        const startTime = Date.now();
+        const fileSize = fs.statSync(filePath).size;
+
+        const markdown = await this.callRemote(filePath, token);
+        if (markdown !== null) {
+            return {
+                markdown,
+                success: true,
+                error: null,
+                bytesProcessed: fileSize,
+                conversionTime: Date.now() - startTime,
+            };
+        }
+
+        return {
+            markdown: "",
+            success: false,
+            error: "Remote conversion returned no result",
+            bytesProcessed: fileSize,
+            conversionTime: Date.now() - startTime,
+        };
+    }
+
+    private async callRemote(filePath: string, token?: string): Promise<string | null> {
+        const config = vscode.workspace.getConfiguration("kiroSdlc");
+        const backendUrl = config.get<string>("backend.url") || "http://127.0.0.1:48721";
+
+        let fileUri = filePath.replace(/\\/g, "/");
+        if (!fileUri.startsWith("/")) { fileUri = "/" + fileUri; }
+        const uri = `file://${fileUri}`;
+
+        const payload = {
+            tool_name: "execute_dynamic_tool",
+            arguments: { toolName: "convert_to_markdown", arguments: { uri } },
+        };
+
+        const body = JSON.stringify(payload);
+        const headers: Record<string, string> = {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(body).toString(),
+        };
+        if (token) { headers["Authorization"] = `Bearer ${token}`; }
+
+        return new Promise<string | null>((resolve) => {
+            const req = http.request(`${backendUrl}/mcp/tools/call`, {
+                method: "POST", headers, timeout: 30000,
+            }, (res) => {
+                let data = "";
+                res.on("data", chunk => { data += chunk; });
+                res.on("end", () => {
+                    if (res.statusCode === 200) {
+                        try {
+                            const parsed = JSON.parse(data);
+                            if (parsed?.content && Array.isArray(parsed.content)) {
+                                const textObj = parsed.content.find((c: any) => c.type === "text");
+                                if (textObj && typeof textObj.text === "string") {
+                                    resolve(textObj.text);
+                                    return;
+                                }
+                            }
+                            resolve(null);
+                        } catch { resolve(null); }
+                    } else { resolve(null); }
+                });
+            });
+            req.on("error", () => resolve(null));
+            req.write(body);
+            req.end();
+        });
+    }
+}

package/extension/src/converter/TextConverter.ts

@@ -0,0 +1,41 @@
+/**
+ * Strategy: Handles text-based formats (txt, csv, json, xml, yaml, yml).
+ * Reads file content directly and wraps in markdown code fences.
+ */
+import * as fs from "fs";
+import { IFileConverter, ConversionResult } from "./IFileConverter";
+
+const TEXT_FORMATS = new Set(["txt", "csv", "json", "xml", "yaml", "yml"]);
+
+export class TextConverter implements IFileConverter {
+    canConvert(format: string): boolean {
+        return TEXT_FORMATS.has(format.toLowerCase());
+    }
+
+    async convert(filePath: string, format: string): Promise<ConversionResult> {
+        const startTime = Date.now();
+        const fileSize = fs.statSync(filePath).size;
+
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const lang = format.toLowerCase() === "yml" ? "yaml" : format.toLowerCase();
+            const markdown = `\`\`\`${lang}\n${content}\n\`\`\``;
+
+            return {
+                markdown,
+                success: true,
+                error: null,
+                bytesProcessed: fileSize,
+                conversionTime: Date.now() - startTime,
+            };
+        } catch (err: any) {
+            return {
+                markdown: "",
+                success: false,
+                error: `Failed to read text file: ${err.message}`,
+                bytesProcessed: fileSize,
+                conversionTime: Date.now() - startTime,
+            };
+        }
+    }
+}

package/extension/src/converter/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Barrel export + backward-compatible convertFileToMarkdown function.
+ */
+export { ConversionResult, IFileConverter } from "./IFileConverter";
+export { TextConverter } from "./TextConverter";
+export { RemoteConverter } from "./RemoteConverter";
+export { LocalFallbackConverter } from "./LocalFallbackConverter";
+export { FileConverterService } from "./FileConverterService";
+
+import { FileConverterService } from "./FileConverterService";
+import { ConversionResult } from "./IFileConverter";
+
+// Re-export helpers needed by external code
+export { isFileTooLarge, isTextFormat, wrapTextContent } from "../converter-helpers";
+
+// Singleton instance for backward compatibility
+let _instance: FileConverterService | null = null;
+
+function getInstance(): FileConverterService {
+    if (!_instance) { _instance = new FileConverterService(); }
+    return _instance;
+}
+
+/**
+ * Backward-compatible wrapper — delegates to FileConverterService singleton.
+ */
+export async function convertFileToMarkdown(
+    filePath: string, format: string, token?: string
+): Promise<ConversionResult> {
+    return getInstance().convert(filePath, format, token);
+}

package/extension/src/converter-helpers.ts

@@ -0,0 +1,125 @@
+/**
+ * Converter helpers — size limits, format checks, text wrapping, and
+ * local fallback conversion via filetomarkdown.
+ */
+
+import * as fs from "fs";
+
+// --- Types ---
+
+export interface ConversionResult {
+    markdown: string;
+    success: boolean;
+    error: string | null;
+    bytesProcessed: number;
+    conversionTime: number;
+}
+
+// --- Constants ---
+
+/** Size limits per format category (in bytes) */
+export const SIZE_LIMITS: Record<string, number> = {
+    pdf: 50 * 1024 * 1024,
+    png: 20 * 1024 * 1024,
+    jpg: 20 * 1024 * 1024,
+    jpeg: 20 * 1024 * 1024,
+    gif: 20 * 1024 * 1024,
+    bmp: 20 * 1024 * 1024,
+    webp: 20 * 1024 * 1024,
+    svg: 20 * 1024 * 1024,
+    default: 50 * 1024 * 1024,
+};
+
+/** Text-based formats that can be read directly */
+const TEXT_FORMATS = new Set(["txt", "csv", "json", "xml", "yaml", "yml"]);
+
+/** Conversion timeout in milliseconds */
+export const CONVERSION_TIMEOUT_MS = 30000;
+
+// --- Lazy-loaded filetomarkdown reference ---
+let filetomarkdownModule: any = null;
+let filetomarkdownLoadAttempted = false;
+
+// --- Public API ---
+
+export function isFileTooLarge(format: string, sizeBytes: number): boolean {
+    const limit = SIZE_LIMITS[format.toLowerCase()] ?? SIZE_LIMITS.default;
+    return sizeBytes > limit;
+}
+
+export function isTextFormat(format: string): boolean {
+    return TEXT_FORMATS.has(format.toLowerCase());
+}
+
+export function wrapTextContent(content: string, format: string): string {
+    const lang = format.toLowerCase() === "yml" ? "yaml" : format.toLowerCase();
+    return `\`\`\`${lang}\n${content}\n\`\`\``;
+}
+
+export function readTextFile(filePath: string, format: string, fileSize: number, startTime: number): ConversionResult {
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return {
+            markdown: wrapTextContent(content, format),
+            success: true,
+            error: null,
+            bytesProcessed: fileSize,
+            conversionTime: Date.now() - startTime,
+        };
+    } catch (err: any) {
+        return {
+            markdown: "",
+            success: false,
+            error: `Failed to read text file: ${err.message}`,
+            bytesProcessed: fileSize,
+            conversionTime: Date.now() - startTime,
+        };
+    }
+}
+
+/**
+ * Lazy-load the filetomarkdown package.
+ */
+export function loadFileToMarkdown(): any {
+    if (filetomarkdownModule) { return filetomarkdownModule; }
+    if (filetomarkdownLoadAttempted) { return null; }
+    filetomarkdownLoadAttempted = true;
+    try {
+        filetomarkdownModule = require("filetomarkdown");
+        return filetomarkdownModule;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Run filetomarkdown conversion with a timeout.
+ */
+export async function convertWithTimeout(ftm: any, filePath: string, timeoutMs: number): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`Conversion timeout: file took longer than ${timeoutMs / 1000}s`));
+        }, timeoutMs);
+
+        const conversionPromise = typeof ftm.convert === "function"
+            ? ftm.convert(filePath)
+            : typeof ftm.default === "function"
+                ? ftm.default(filePath)
+                : typeof ftm === "function"
+                    ? ftm(filePath)
+                    : Promise.reject(new Error("filetomarkdown: no convert function found"));
+
+        Promise.resolve(conversionPromise)
+            .then((result: any) => {
+                clearTimeout(timer);
+                if (typeof result === "string") { resolve(result); }
+                else if (result && typeof result.content === "string") { resolve(result.content); }
+                else if (result && typeof result.markdown === "string") { resolve(result.markdown); }
+                else { resolve(String(result || "")); }
+            })
+            .catch((err: any) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+    });
+}

package/extension/src/converter.ts

@@ -0,0 +1,17 @@
+/**
+ * Multi-format document converter — backward-compatible entry point.
+ * Delegates to Strategy-based converter/ module.
+ */
+export {
+    ConversionResult,
+    IFileConverter,
+    FileConverterService,
+    TextConverter,
+    RemoteConverter,
+    LocalFallbackConverter,
+    convertFileToMarkdown,
+    isFileTooLarge,
+    isTextFormat,
+    wrapTextContent,
+} from "./converter/index";
+ 

package/extension/src/debug-logger.ts

@@ -0,0 +1,23 @@
+/**
+ * Debug Logger — KSA-240
+ * Singleton OutputChannel logger visible in Output → "Kiro SDLC Debug"
+ */
+import * as vscode from "vscode";
+
+let channel: vscode.OutputChannel | undefined;
+
+export function debugLog(message: string): void {
+  if (!channel) {
+    channel = vscode.window.createOutputChannel("Kiro SDLC Debug");
+  }
+  const ts = new Date().toISOString().slice(11, 23);
+  channel.appendLine(`[${ts}] ${message}`);
+}
+
+export function debugError(message: string, error?: Error): void {
+  if (!channel) {
+    channel = vscode.window.createOutputChannel("Kiro SDLC Debug");
+  }
+  const ts = new Date().toISOString().slice(11, 23);
+  channel.appendLine(`[${ts}] ERROR: ${message}${error ? ` — ${error.message}` : ""}`);
+}

package/extension/src/diagnostics-provider.ts

@@ -0,0 +1,150 @@
+/**
+ * DiagnosticsProvider — KSA-178
+ * On file save → queries code_search for issues → shows as VS Code diagnostics.
+ * Also provides CodeActions for quick fixes.
+ */
+
+import * as vscode from "vscode";
+import { McpServerManager } from "./mcp-server-manager";
+
+interface CodeIssue {
+  file: string;
+  line: number;
+  column: number;
+  endLine: number;
+  endColumn: number;
+  message: string;
+  severity: "error" | "warning" | "info" | "hint";
+  code: string;
+  suggestion?: string;
+}
+
+const DIAGNOSTIC_SOURCE = "Kiro Code Intelligence";
+
+/**
+ * Register the diagnostics provider. Auto-triggers on file save.
+ */
+export function registerDiagnosticsProvider(
+  context: vscode.ExtensionContext,
+  mcpManager: McpServerManager
+): vscode.DiagnosticCollection {
+  const diagnostics = vscode.languages.createDiagnosticCollection("kiroCodeIntel");
+  context.subscriptions.push(diagnostics);
+
+  // Analyze on save
+  context.subscriptions.push(
+    vscode.workspace.onDidSaveTextDocument((doc) => {
+      analyzeDocument(doc, mcpManager, diagnostics);
+    })
+  );
+
+  // Register code action provider for all languages
+  context.subscriptions.push(
+    vscode.languages.registerCodeActionsProvider(
+      { scheme: "file" },
+      new KiroCodeActionProvider(diagnostics),
+      { providedCodeActionKinds: [vscode.CodeActionKind.QuickFix] }
+    )
+  );
+
+  // Clear diagnostics when file is closed
+  context.subscriptions.push(
+    vscode.workspace.onDidCloseTextDocument((doc) => {
+      diagnostics.delete(doc.uri);
+    })
+  );
+
+  return diagnostics;
+}
+
+async function analyzeDocument(
+  doc: vscode.TextDocument,
+  mcpManager: McpServerManager,
+  diagnostics: vscode.DiagnosticCollection
+): Promise<void> {
+  if (mcpManager.status !== "running") { return; }
+
+  const relativePath = vscode.workspace.asRelativePath(doc.uri);
+  try {
+    const raw = await mcpManager.invokeTool("code_search", {
+      query: `issues in ${relativePath}`,
+      file: relativePath,
+      limit: 50,
+    });
+    const issues = parseIssues(raw, doc);
+    diagnostics.set(doc.uri, issues);
+  } catch {
+    // Silently fail — don't disrupt user workflow
+  }
+}
+
+function parseIssues(raw: string, doc: vscode.TextDocument): vscode.Diagnostic[] {
+  try {
+    const parsed = JSON.parse(raw);
+    const items: CodeIssue[] = Array.isArray(parsed) ? parsed : (parsed.issues || parsed.results || []);
+    return items.map((issue) => toDiagnostic(issue, doc)).filter(Boolean) as vscode.Diagnostic[];
+  } catch {
+    return [];
+  }
+}
+
+function toDiagnostic(issue: CodeIssue, doc: vscode.TextDocument): vscode.Diagnostic | null {
+  const line = Math.max(0, (issue.line || 1) - 1);
+  const col = Math.max(0, (issue.column || 1) - 1);
+  const endLine = Math.max(line, (issue.endLine || issue.line || 1) - 1);
+  const endCol = issue.endColumn ? issue.endColumn - 1 : doc.lineAt(endLine).text.length;
+
+  const range = new vscode.Range(line, col, endLine, endCol);
+  const severity = mapSeverity(issue.severity);
+  const diagnostic = new vscode.Diagnostic(range, issue.message, severity);
+  diagnostic.source = DIAGNOSTIC_SOURCE;
+  diagnostic.code = issue.code || "kiro-issue";
+
+  if (issue.suggestion) {
+    diagnostic.relatedInformation = [
+      new vscode.DiagnosticRelatedInformation(
+        new vscode.Location(doc.uri, range),
+        `Fix: ${issue.suggestion}`
+      ),
+    ];
+  }
+
+  return diagnostic;
+}
+
+function mapSeverity(severity: string): vscode.DiagnosticSeverity {
+  switch (severity) {
+    case "error": return vscode.DiagnosticSeverity.Error;
+    case "warning": return vscode.DiagnosticSeverity.Warning;
+    case "hint": return vscode.DiagnosticSeverity.Hint;
+    default: return vscode.DiagnosticSeverity.Information;
+  }
+}
+
+class KiroCodeActionProvider implements vscode.CodeActionProvider {
+  constructor(private readonly diagnostics: vscode.DiagnosticCollection) {}
+
+  provideCodeActions(
+    document: vscode.TextDocument,
+    range: vscode.Range,
+    context: vscode.CodeActionContext
+  ): vscode.CodeAction[] {
+    const actions: vscode.CodeAction[] = [];
+
+    for (const diagnostic of context.diagnostics) {
+      if (diagnostic.source !== DIAGNOSTIC_SOURCE) { continue; }
+      if (!diagnostic.relatedInformation?.length) { continue; }
+
+      const suggestion = diagnostic.relatedInformation[0].message.replace("Fix: ", "");
+      const action = new vscode.CodeAction(
+        `Fix: ${suggestion}`,
+        vscode.CodeActionKind.QuickFix
+      );
+      action.diagnostics = [diagnostic];
+      action.isPreferred = true;
+      actions.push(action);
+    }
+
+    return actions;
+  }
+}