sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/platform-swap/swap-commands.ts

@@ -0,0 +1,161 @@
+/**
+ * SwapCommands — registers VS Code commands for platform swap operations.
+ * Handles QuickPick UI, confirmation dialogs, and progress notifications.
+ */
+
+import * as vscode from "vscode";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { PlatformId } from "./types";
+import { PlatformDetector } from "./platform-detector";
+import { SwapExecutor } from "./swap-executor";
+import { StateManager } from "./state-manager";
+import { PlatformStatusBar } from "./platform-status-bar";
+import { PLATFORM_DEFINITIONS, getPlatformDefinition } from "./platform-config";
+
+/** Register all platform swap commands */
+export function registerSwapCommands(
+  context: vscode.ExtensionContext,
+  workspaceRoot: string,
+  detector: PlatformDetector,
+  executor: SwapExecutor,
+  stateManager: StateManager,
+  statusBar: PlatformStatusBar,
+): void {
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      "kiroSdlc.swapPlatform",
+      () => handleSwapPlatform(workspaceRoot, detector, executor, stateManager, statusBar),
+    ),
+    vscode.commands.registerCommand(
+      "kiroSdlc.restoreBackup",
+      () => handleRestoreBackup(executor, stateManager, statusBar, detector),
+    ),
+    vscode.commands.registerCommand(
+      "kiroSdlc.platformStatus",
+      () => handlePlatformStatus(detector, stateManager),
+    ),
+  );
+}
+
+async function handleSwapPlatform(
+  workspaceRoot: string,
+  detector: PlatformDetector,
+  executor: SwapExecutor,
+  stateManager: StateManager,
+  statusBar: PlatformStatusBar,
+): Promise<void> {
+  const state = await stateManager.read();
+  const available = await getAvailablePlatforms(workspaceRoot);
+
+  if (available.length === 0) {
+    vscode.window.showErrorMessage("No platform configs available.");
+    return;
+  }
+
+  const items = buildQuickPickItems(available, state.activePlatform);
+  const selected = await vscode.window.showQuickPick(items, {
+    placeHolder: "Select target platform",
+  });
+  if (!selected) { return; }
+
+  const targetId = selected.platformId;
+  if (targetId === state.activePlatform) {
+    vscode.window.showInformationMessage(
+      `Already using ${selected.label} config.`);
+    return;
+  }
+
+  statusBar.showSwapping();
+  const result = await executor.executeSwap(state.activePlatform, targetId);
+
+  if (result.success) {
+    const detected = detector.detect();
+    statusBar.update(targetId, detected.platform);
+    vscode.window.showInformationMessage(
+      `Agent config swapped to ${selected.label}. Backup: ${result.backupPath}`);
+  } else {
+    statusBar.showError(result.error || "Swap failed");
+    vscode.window.showErrorMessage(
+      `Swap failed: ${result.error}`);
+  }
+}
+
+async function handleRestoreBackup(
+  executor: SwapExecutor,
+  stateManager: StateManager,
+  statusBar: PlatformStatusBar,
+  detector: PlatformDetector,
+): Promise<void> {
+  const state = await stateManager.read();
+  if (state.backups.length === 0) {
+    vscode.window.showInformationMessage("No backups available.");
+    return;
+  }
+
+  const items = state.backups.map((b) => ({
+    label: `${b.platform} — ${b.createdAt}`,
+    description: `${b.fileCount} files`,
+    backup: b,
+  }));
+
+  const selected = await vscode.window.showQuickPick(items, {
+    placeHolder: "Select backup to restore",
+  });
+  if (!selected) { return; }
+
+  statusBar.showSwapping();
+  const result = await executor.executeRestore(
+    state.activePlatform, selected.backup.platform, selected.backup);
+
+  if (result.success) {
+    const detected = detector.detect();
+    statusBar.update(result.toPlatform, detected.platform);
+    vscode.window.showInformationMessage(
+      `Restored ${selected.backup.platform} config from backup.`);
+  } else {
+    statusBar.showError(result.error || "Restore failed");
+  }
+}
+
+async function handlePlatformStatus(
+  detector: PlatformDetector,
+  stateManager: StateManager,
+): Promise<void> {
+  const state = await stateManager.read();
+  const detected = detector.detect();
+  const msg = `Active: ${state.activePlatform} | Detected: ${detected.platform} | Backups: ${state.backups.length}`;
+  vscode.window.showInformationMessage(msg);
+}
+
+async function getAvailablePlatforms(workspaceRoot: string): Promise<PlatformId[]> {
+  const available: PlatformId[] = [];
+  for (const def of PLATFORM_DEFINITIONS) {
+    const convPath = path.join(workspaceRoot, def.conversionPath);
+    try {
+      await fs.access(convPath);
+      available.push(def.id);
+    } catch { /* not available */ }
+  }
+  return available;
+}
+
+interface PlatformQuickPickItem extends vscode.QuickPickItem {
+  platformId: PlatformId;
+}
+
+function buildQuickPickItems(
+  available: PlatformId[],
+  currentPlatform: PlatformId,
+): PlatformQuickPickItem[] {
+  return available.map((id) => {
+    const def = getPlatformDefinition(id)!;
+    const isCurrent = id === currentPlatform;
+    return {
+      label: def.displayName,
+      description: isCurrent ? "$(check) current" : "",
+      detail: `conversions/${id}/ ready`,
+      platformId: id,
+    };
+  });
+}

package/extension/src/platform-swap/swap-executor.ts

@@ -0,0 +1,193 @@
+/**
+ * SwapExecutor — orchestrates the swap sequence using Template Method pattern.
+ * Fixed sequence: validate → backup → clean → copy → update state.
+ * Includes rollback on failure.
+ */
+
+import * as vscode from "vscode";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { PlatformId, SwapResult, MergeReport, BackupRecord } from "./types";
+import { BackupManager } from "./backup-manager";
+import { StateManager } from "./state-manager";
+import { getPlatformDefinition, PROTECTED_PATHS } from "./platform-config";
+
+export class SwapExecutor {
+  private static readonly DELETE_RETRIES = 3;
+  private static readonly RETRY_DELAY_MS = 500;
+
+  constructor(
+    private readonly workspaceRoot: string,
+    private readonly backupManager: BackupManager,
+    private readonly stateManager: StateManager,
+    private readonly outputChannel: vscode.OutputChannel,
+  ) {}
+
+  /** Execute a platform swap: backup → delete old → copy new → update state */
+  async executeSwap(
+    fromPlatform: PlatformId,
+    toPlatform: PlatformId,
+  ): Promise<SwapResult> {
+    if (fromPlatform === toPlatform) {
+      return this.buildResult(false, fromPlatform, toPlatform,
+        undefined, `Already using ${toPlatform}`);
+    }
+
+    const targetDef = getPlatformDefinition(toPlatform);
+    if (!targetDef) {
+      return this.buildResult(false, fromPlatform, toPlatform,
+        undefined, "Platform definition not found");
+    }
+
+    const conversionExists = await this.pathExists(
+      path.join(this.workspaceRoot, targetDef.conversionPath),
+    );
+    if (!conversionExists) {
+      return this.buildResult(false, fromPlatform, toPlatform,
+        undefined, "Platform config not available");
+    }
+
+    // Step 1: Backup current
+    const fromDef = getPlatformDefinition(fromPlatform);
+    let backupRecord: BackupRecord | undefined;
+    if (fromDef) {
+      try {
+        backupRecord = await this.backupManager.createBackup(
+          fromPlatform, fromDef.directories);
+        this.log(`Backup created: ${backupRecord.path}`);
+      } catch (err) {
+        return this.buildResult(false, fromPlatform, toPlatform,
+          undefined, `Backup failed: ${String(err)}`);
+      }
+    }
+
+    // Step 2: Delete old platform dirs
+    try {
+      await this.deletePlatformDirs(fromPlatform);
+      this.log(`Deleted ${fromPlatform} directories`);
+    } catch (err) {
+      this.log(`Delete failed, preserving backup: ${String(err)}`);
+      return this.buildResult(false, fromPlatform, toPlatform,
+        backupRecord?.path, `Delete failed: ${String(err)}`);
+    }
+
+    // Step 3: Copy new platform dirs
+    try {
+      await this.copyFromConversions(toPlatform);
+      this.log(`Copied ${toPlatform} from conversions`);
+    } catch (err) {
+      // Rollback: restore from backup
+      if (backupRecord) {
+        await this.rollback(backupRecord);
+        this.log("Rolled back to backup after copy failure");
+      }
+      return this.buildResult(false, fromPlatform, toPlatform,
+        backupRecord?.path, `Copy failed: ${String(err)}`);
+    }
+
+    // Step 4: Update state
+    await this.stateManager.updateActivePlatform(toPlatform);
+    if (backupRecord) {
+      await this.stateManager.addBackupRecord(backupRecord);
+      await this.backupManager.pruneOldBackups(fromPlatform);
+    }
+
+    this.log(`Swap complete: ${fromPlatform} → ${toPlatform}`);
+    return this.buildResult(true, fromPlatform, toPlatform,
+      backupRecord?.path);
+  }
+
+  /** Restore from a backup record */
+  async executeRestore(
+    currentPlatform: PlatformId,
+    targetPlatform: PlatformId,
+    backup: BackupRecord,
+  ): Promise<SwapResult> {
+    // Backup current before restore
+    const currentDef = getPlatformDefinition(currentPlatform);
+    if (currentDef) {
+      await this.backupManager.createBackup(
+        currentPlatform, currentDef.directories);
+    }
+
+    // Delete current dirs
+    await this.deletePlatformDirs(currentPlatform);
+
+    // Restore from backup
+    await this.backupManager.restoreFromBackup(backup);
+
+    // Update state
+    await this.stateManager.updateActivePlatform(targetPlatform);
+
+    this.log(`Restored ${targetPlatform} from backup`);
+    return this.buildResult(true, currentPlatform, targetPlatform,
+      backup.path);
+  }
+
+  /** Delete all directories for a platform with retry logic */
+  private async deletePlatformDirs(platform: PlatformId): Promise<void> {
+    const def = getPlatformDefinition(platform);
+    if (!def) { return; }
+
+    for (const dir of def.directories) {
+      if (this.isProtected(dir)) { continue; }
+      const fullPath = path.join(this.workspaceRoot, dir);
+      await this.deleteWithRetry(fullPath);
+    }
+  }
+
+  /** Copy platform files from conversions directory */
+  private async copyFromConversions(platform: PlatformId): Promise<void> {
+    const def = getPlatformDefinition(platform);
+    if (!def) {
+      throw new Error(`No definition for platform: ${platform}`);
+    }
+    const srcBase = path.join(this.workspaceRoot, def.conversionPath);
+    await this.backupManager.copyDirectory(srcBase, this.workspaceRoot);
+  }
+
+  /** Restore workspace from backup after failed swap */
+  private async rollback(backup: BackupRecord): Promise<void> {
+    await this.backupManager.restoreFromBackup(backup);
+  }
+
+  /** Delete path with retry on EBUSY/EPERM */
+  private async deleteWithRetry(targetPath: string): Promise<void> {
+    for (let attempt = 1; attempt <= SwapExecutor.DELETE_RETRIES; attempt++) {
+      try {
+        await fs.rm(targetPath, { recursive: true, force: true });
+        return;
+      } catch (err: any) {
+        const isRetriable = err.code === "EBUSY" || err.code === "EPERM";
+        if (!isRetriable || attempt === SwapExecutor.DELETE_RETRIES) {
+          throw err;
+        }
+        await this.delay(SwapExecutor.RETRY_DELAY_MS);
+      }
+    }
+  }
+
+  private isProtected(dirPath: string): boolean {
+    return PROTECTED_PATHS.some((p) =>
+      dirPath.startsWith(p) || dirPath === p);
+  }
+
+  private buildResult(
+    success: boolean, from: PlatformId, to: PlatformId,
+    backupPath?: string, error?: string,
+  ): SwapResult {
+    return { success, fromPlatform: from, toPlatform: to, backupPath, error };
+  }
+
+  private log(message: string): void {
+    this.outputChannel.appendLine(`[PlatformSwap] ${message}`);
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  private async pathExists(p: string): Promise<boolean> {
+    try { await fs.access(p); return true; } catch { return false; }
+  }
+}

package/extension/src/platform-swap/types.ts

@@ -0,0 +1,68 @@
+/**
+ * Type definitions for the Platform Swap feature.
+ * All interfaces, enums, and type aliases used across platform-swap modules.
+ */
+
+/** Supported platform identifiers */
+export type PlatformId = "kiro" | "claude-code" | "github-copilot" | "antigravity";
+
+/** Detection signal types */
+export type SignalType = "appName" | "extension" | "envVar";
+
+/** Result of IDE platform detection */
+export interface DetectionResult {
+  platform: PlatformId;
+  detectedAt: number;
+  signals: string[];
+}
+
+/** Signal used to identify a platform */
+export interface DetectionSignal {
+  type: SignalType;
+  pattern: string;
+  priority: number;
+}
+
+/** Static definition of a platform's config structure */
+export interface PlatformDefinition {
+  id: PlatformId;
+  displayName: string;
+  directories: string[];
+  conversionPath: string;
+  detectionSignals: DetectionSignal[];
+}
+
+/** Persistent state stored in .agent-config.json */
+export interface AgentConfigState {
+  activePlatform: PlatformId;
+  lastSwapAt?: string;
+  autoSwap: boolean;
+  platformOverride: PlatformId | null;
+  backups: BackupRecord[];
+}
+
+/** Record of a single backup operation */
+export interface BackupRecord {
+  platform: PlatformId;
+  path: string;
+  createdAt: string;
+  complete: boolean;
+  fileCount: number;
+}
+
+/** Result returned after a swap or restore operation */
+export interface SwapResult {
+  success: boolean;
+  fromPlatform: PlatformId;
+  toPlatform: PlatformId;
+  backupPath?: string;
+  error?: string;
+}
+
+/** Summary of merge-on-restore operations */
+export interface MergeReport {
+  restored: number;
+  updated: number;
+  preserved: number;
+  added: number;
+}

package/extension/src/proxy/HttpClient.ts

@@ -0,0 +1,120 @@
+/**
+ * HttpClient — Auth-injecting HTTP wrapper for backend communication.
+ * Handles token injection, 401 retry, timeouts, and streaming.
+ */
+
+import { AuthManager } from "../auth/AuthManager";
+
+export class HttpError extends Error {
+  constructor(public readonly statusCode: number, message: string) {
+    super(message);
+    this.name = "HttpError";
+  }
+}
+
+export interface ToolResult {
+  content: Array<{ type: string; text: string }>;
+}
+
+export class HttpClient {
+  constructor(
+    private _baseUrl: string,
+    private readonly authManager: AuthManager
+  ) {}
+
+  get baseUrl(): string {
+    return this._baseUrl;
+  }
+
+  set baseUrl(url: string) {
+    this._baseUrl = url;
+  }
+
+  async getAuthHeaders(): Promise<Record<string, string>> {
+    const token = await this.authManager.getAccessToken();
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (token) {
+      headers["Authorization"] = "Bearer " + token;
+    }
+    return headers;
+  }
+
+  async get<T>(path: string, timeout?: number, _retried = false): Promise<T> {
+    const headers = await this.getAuthHeaders();
+    const url = this._baseUrl + path;
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: AbortSignal.timeout(timeout || 10000),
+    });
+    if (response.status === 401 && !_retried) {
+      await this.authManager.refreshToken();
+      return this.get(path, timeout, true);
+    }
+    if (!response.ok) {
+      throw new HttpError(response.status, await response.text());
+    }
+    return response.json() as Promise<T>;
+  }
+
+  async post<T>(path: string, body: unknown, timeout?: number, _retried = false): Promise<T> {
+    const headers = await this.getAuthHeaders();
+    const url = this._baseUrl + path;
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeout || 10000),
+    });
+    if (response.status === 401 && !_retried) {
+      await this.authManager.refreshToken();
+      return this.post(path, body, timeout, true);
+    }
+    if (!response.ok) {
+      throw new HttpError(response.status, await response.text());
+    }
+    return response.json() as Promise<T>;
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+    return this.post<ToolResult>("/mcp/tools/call", { tool_name: name, arguments: args }, 300000);
+  }
+
+  async stream(path: string, body: unknown, timeout?: number, _retried = false): Promise<ReadableStream<Uint8Array>> {
+    const headers = await this.getAuthHeaders();
+    const url = this._baseUrl + path;
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeout || 120000),
+    });
+    if (response.status === 401 && !_retried) {
+      await this.authManager.refreshToken();
+      return this.stream(path, body, timeout, true);
+    }
+    if (!response.ok) {
+      throw new HttpError(response.status, await response.text());
+    }
+    if (!response.body) {
+      throw new HttpError(0, "No response body for streaming");
+    }
+    return response.body;
+  }
+
+  /**
+   * Simple health check — GET /health, returns true if 200.
+   */
+  async healthCheck(timeout?: number): Promise<boolean> {
+    try {
+      const url = this._baseUrl + "/health";
+      const response = await fetch(url, {
+        method: "GET",
+        signal: AbortSignal.timeout(timeout || 5000),
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}

package/extension/src/proxy/ToolProxy.ts

@@ -0,0 +1,58 @@
+/**
+ * ToolProxy — Routes tool calls between local execution and remote backend.
+ * Local tools (embed_images, etc.) run in-extension; everything else forwards to backend.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import * as vscode from "vscode";
+import { HttpClient, ToolResult } from "./HttpClient";
+
+export interface ToolDefinition {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+}
+
+export class ToolProxy {
+  private localTools = new Set<string>();
+  private toolRegistry: Map<string, ToolDefinition> = new Map();
+
+  constructor(private readonly httpClient: HttpClient) {}
+
+  async refreshTools(): Promise<void> {
+    try {
+      const tools = await this.httpClient.get<ToolDefinition[]>("/mcp/tools/list");
+      this.toolRegistry.clear();
+      for (const tool of tools) { this.toolRegistry.set(tool.name, tool); }
+    } catch { /* non-fatal */ }
+  }
+
+  async callTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+    if (this.localTools.has(name)) { return this.executeLocal(name, args); }
+    
+    // Wrapper: Read local file content before sending to remote backend
+    const newArgs = { ...args };
+    if (name === "mem_ingest_file" && typeof args.file_path === "string") {
+      try {
+        newArgs.content = fs.readFileSync(args.file_path, "utf-8");
+      } catch (err: any) {
+        return { content: [{ type: "text", text: `Wrapper Error: Cannot read local file ${args.file_path}: ${err.message}` }] };
+      }
+    }
+    
+    return this.httpClient.callTool(name, newArgs);
+  }
+
+  getAvailableTools(): ToolDefinition[] { return [...this.toolRegistry.values()]; }
+
+  async invokeTool(name: string, args: Record<string, unknown>): Promise<string> {
+    const result = await this.callTool(name, args);
+    if (result.content && result.content.length > 0) { return result.content.map((c) => c.text).join("\n"); }
+    return "";
+  }
+
+  private async executeLocal(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+    return { content: [{ type: "text", text: "Unknown local tool: " + name }] };
+  }
+}