sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/remote-backend-client.ts

@@ -0,0 +1,185 @@
+import * as vscode from "vscode";
+import * as fs from "fs";
+import { ServerStatus } from "./types";
+import { AuthManager } from "./auth/AuthManager";
+import * as http from "http";
+import * as https from "https";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { z } from "zod";
+import { executeLocalTool, wrapToolArguments } from "./backend-local-tools";
+
+/** Tools that execute locally without forwarding to backend */
+const LOCAL_TOOLS = new Set(["stream_write_file", "embed_image"]);
+
+/** Maximum body size accepted by wrapper server (1MB) */
+const MAX_BODY_SIZE = 1024 * 1024;
+
+/** Health check timeout in milliseconds */
+const HEALTH_TIMEOUT_MS = 5000;
+
+export class RemoteBackendClient implements vscode.Disposable {
+  private _status: ServerStatus = "stopped";
+  private _port: number | null = null;
+  private _wrapperPort: number | null = null;
+  private readonly _onStatusChange = new vscode.EventEmitter<ServerStatus>();
+  readonly onStatusChange = this._onStatusChange.event;
+  private mcpClient: Client | null = null;
+  private httpServer: http.Server | null = null;
+  private requestId = 0;
+  private readonly _onNotification = new vscode.EventEmitter<{ method: string; params?: any }>();
+  public readonly onNotification = this._onNotification.event;
+
+  constructor(
+    private readonly workspaceFolder: string,
+    private readonly outputChannel: vscode.OutputChannel,
+    private readonly authManager: AuthManager | undefined,
+    private readonly backendUrl: string
+  ) { this._port = this.extractPort(backendUrl); }
+
+  get status(): ServerStatus { return this._status; }
+  get port(): number | null { return this._wrapperPort || this._port; }
+
+  private extractPort(url: string): number | null {
+    try { const p = new URL(url); return p.port ? parseInt(p.port, 10) : (p.protocol === "https:" ? 443 : 80); }
+    catch (err) { this.outputChannel.appendLine(`[RemoteBackendClient] Invalid backend URL: ${(err as Error).message}`); return null; }
+  }
+
+  private setStatus(status: ServerStatus) {
+    if (this._status !== status) { this._status = status; this._onStatusChange.fire(status); }
+  }
+
+  async connect(): Promise<void> {
+    this.setStatus("starting");
+    try {
+      await this.checkHealth();
+      this.mcpClient = new Client({ name: "kiro-sdlc-extension", version: "2.0.0" }, { capabilities: {} });
+      this.mcpClient.fallbackNotificationHandler = async (n) => { this._onNotification.fire({ method: n.method, params: n.params }); };
+      const url = new URL(`${this.backendUrl}/mcp`);
+      const token = this.authManager?.getTokenSync();
+      const requestInit: Record<string, any> = {};
+      if (token) { requestInit.headers = { "Authorization": `Bearer ${token}` }; }
+      const transport = new StreamableHTTPClientTransport(url, { requestInit });
+      await this.mcpClient.connect(transport);
+      await this.startLocalServer();
+      this.setStatus("running");
+      this.outputChannel.appendLine(`[RemoteBackendClient] Connected to ${this.backendUrl}`);
+    } catch (err: any) {
+      this.setStatus("crashed");
+      this.outputChannel.appendLine(`[RemoteBackendClient] Connection failed: ${err.message}`);
+      throw err;
+    }
+  }
+
+  private async startLocalServer(): Promise<void> {
+    const port = vscode.workspace.getConfiguration("kiroSdlc").get<number>("mcpServerPort", 9181);
+    return new Promise((resolve, reject) => {
+      const server = http.createServer(async (req, res) => {
+        const u = new URL(req.url || "/", "http://localhost");
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+        try {
+          if (u.pathname === "/mcp") { await this.handleMcpRequest(req, res); return; }
+          if (u.pathname === "/health") { res.writeHead(200, { "Content-Type": "application/json" }); res.end('{"status":"ok","mode":"wrapper"}'); return; }
+          res.writeHead(404); res.end('{"error":"Not found"}');
+        } catch (err: unknown) {
+          if (!res.headersSent) { res.writeHead(500); res.end(JSON.stringify({ error: (err as Error).message })); }
+        }
+      });
+      server.on("error", (err) => {
+        this.outputChannel.appendLine(`[WrapperServer] Error: ${err.message}`);
+        if (!this.httpServer) { reject(err); }
+      });
+      server.listen(port, "127.0.0.1", () => {
+        this._wrapperPort = (server.address() as import("net").AddressInfo).port;
+        this.httpServer = server;
+        this.outputChannel.appendLine(`[WrapperServer] Listening on port ${this._wrapperPort}`);
+        resolve();
+      });
+    });
+  }
+
+  private readBody(req: http.IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      let size = 0;
+      req.on("data", (chunk: Buffer) => {
+        size += chunk.length;
+        if (size > MAX_BODY_SIZE) {
+          req.destroy();
+          reject(new Error(`Request body exceeds maximum size (${MAX_BODY_SIZE} bytes)`));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+      req.on("error", reject);
+    });
+  }
+
+  private async handleMcpRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    if (req.method !== "POST") { res.writeHead(405); res.end('{"error":"Method not allowed"}'); return; }
+    const contentType = req.headers["content-type"] || "";
+    if (!contentType.includes("application/json")) { res.writeHead(415); res.end('{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Unsupported Content-Type, expected application/json"}}'); return; }
+    const body = await this.readBody(req);
+    let jsonRpc: any;
+    try { jsonRpc = JSON.parse(body); } catch (err) { this.outputChannel.appendLine(`[WrapperServer] JSON parse error: ${(err as Error).message}`); res.writeHead(400); res.end('{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Parse error"}}'); return; }
+    if (jsonRpc.id === undefined) jsonRpc.id = ++this.requestId;
+    if (!this.mcpClient) { res.writeHead(503); res.end(JSON.stringify({ jsonrpc: "2.0", id: jsonRpc.id, error: { code: -32002, message: "Backend not connected" } })); return; }
+    try {
+      if (jsonRpc.method === "tools/call" && jsonRpc.params) {
+        const name = jsonRpc.params.name as string;
+        const args = (jsonRpc.params.arguments || {}) as Record<string, unknown>;
+        if (LOCAL_TOOLS.has(name)) {
+          const result = await executeLocalTool(name, args);
+          res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ jsonrpc: "2.0", id: jsonRpc.id, result })); return;
+        }
+        jsonRpc.params.arguments = wrapToolArguments(name, args);
+      }
+      const response = await this.mcpClient.request({ method: jsonRpc.method, params: jsonRpc.params }, z.any());
+      res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ jsonrpc: "2.0", id: jsonRpc.id, result: response }));
+    } catch (err: any) {
+      res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify({ jsonrpc: "2.0", id: jsonRpc.id, error: { code: err.code || -32603, message: err.message } }));
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.httpServer) {
+      await new Promise<void>((resolve) => this.httpServer!.close(() => resolve()));
+      this.httpServer = null;
+    }
+    if (this.mcpClient) { await this.mcpClient.close(); this.mcpClient = null; }
+    this.setStatus("stopped");
+  }
+
+  async spawn(): Promise<void> { await this.connect(); }
+  async kill(): Promise<void> { await this.disconnect(); }
+  async restart(): Promise<void> { await this.disconnect(); await this.connect(); }
+  async reconnect(): Promise<void> { await this.disconnect(); await this.connect(); }
+
+  private async checkHealth(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const req = (this.backendUrl.startsWith("https") ? https : http).get(`${this.backendUrl}/health`, (res) => {
+        if (res.statusCode === 200) { resolve(); } else { reject(new Error(`Health check failed: ${res.statusCode}`)); }
+      });
+      req.on("error", reject);
+      req.setTimeout(HEALTH_TIMEOUT_MS, () => { req.destroy(); reject(new Error("Health check timed out")); });
+    });
+  }
+
+  async invokeTool(name: string, args: Record<string, unknown>): Promise<string> {
+    if (this._status !== "running" || !this.mcpClient) { throw new Error("Backend not connected."); }
+    const finalArgs = wrapToolArguments(name, args);
+    const result = await this.mcpClient.callTool({ name, arguments: finalArgs });
+    if (result.isError) { throw new Error(`Tool execution failed: ${JSON.stringify(result.content)}`); }
+    return JSON.stringify(result);
+  }
+
+  dispose(): void {
+    this.disconnect().catch(() => {});
+    this._onNotification.dispose();
+    this._onStatusChange.dispose();
+  }
+}

package/extension/src/services/IndexerHttpClient.ts

@@ -0,0 +1,129 @@
+/**
+ * HTTP client for indexer operations — document ingestion and source file upload.
+ */
+import * as vscode from "vscode";
+import * as path from "path";
+
+export interface DocEntry {
+    path: string;
+    type: string;
+    ticket: string;
+    format?: string;
+    content?: string;
+}
+
+export interface FileEntry {
+    path: string;
+    content: string;
+}
+
+export interface IngestResult {
+    ingested: number;
+    errors: number;
+    summary: string;
+}
+
+export interface UploadResult {
+    uploaded: number;
+    errors: number;
+    summary: string;
+}
+
+export class IndexerHttpClient {
+    constructor(private readonly backendUrl: string) {}
+
+    async ingestDocuments(
+        docs: DocEntry[],
+        report: vscode.Progress<{ message?: string }>,
+        token?: string
+    ): Promise<IngestResult> {
+        const url = `${this.backendUrl}/mcp/tools/call`;
+        let ingested = 0;
+        let errors = 0;
+
+        const http = await import("http");
+        for (let i = 0; i < docs.length; i++) {
+            const d = docs[i];
+            if (i % 10 === 0) { report.report({ message: `Ingesting ${i + 1}/${docs.length} files...` }); }
+
+            let fileContent = d.content;
+            if (!fileContent) { fileContent = await this.readFileContent(d.path); }
+            if (fileContent) { await this.uploadDocumentFile(d.path, fileContent, token); }
+
+            const payload = {
+                tool_name: "mem_ingest_file",
+                arguments: { file_path: d.path, type: d.type, format: "markdown", ...(fileContent ? { content: fileContent } : {}) },
+            };
+            const success = await this.httpPost(url, payload, token, http);
+            if (success) { ingested++; } else { errors++; }
+        }
+
+        const summary = `✅ Indexed: ${ingested} files` + (errors > 0 ? `, ⚠️ Failed: ${errors}` : ``);
+        return { ingested, errors, summary };
+    }
+
+    async uploadSourceFiles(
+        report: vscode.Progress<{ message?: string }>,
+        token?: string
+    ): Promise<UploadResult> {
+        const files = await vscode.workspace.findFiles(
+            "**/*.{ts,js,kt,java,py,go,rs,tsx,jsx}", "{node_modules,dist,.git,build,out,backend}/**"
+        );
+        if (files.length === 0) { return { uploaded: 0, errors: 0, summary: "ℹ️ No source files found" }; }
+
+        const url = `${this.backendUrl}/api/index/source`;
+        let uploaded = 0;
+        let errors = 0;
+
+        for (let i = 0; i < files.length; i += 50) {
+            report.report({ message: `Uploading source files ${i + 1}/${files.length}...` });
+            const batch = files.slice(i, i + 50);
+            const entries = await Promise.all(
+                batch.map(async (file) => {
+                    const content = await vscode.workspace.fs.readFile(file);
+                    return { path: vscode.workspace.asRelativePath(file), content: Buffer.from(content).toString("utf-8") };
+                })
+            );
+            const http = await import("http");
+            const success = await this.httpPost(url, { files: entries }, token, http);
+            if (success) { uploaded += batch.length; } else { errors += batch.length; }
+        }
+
+        const summary = `✅ Uploaded ${uploaded} source files` + (errors > 0 ? `, ⚠️ Failed: ${errors}` : "");
+        return { uploaded, errors, summary };
+    }
+
+    private async uploadDocumentFile(relPath: string, content: string, token?: string): Promise<boolean> {
+        const http = require("http");
+        return this.httpPost(`${this.backendUrl}/api/index/document`, { path: relPath, content }, token, http);
+    }
+
+    private async readFileContent(relPath: string): Promise<string | undefined> {
+        try {
+            const root = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+            if (root) {
+                const raw = await vscode.workspace.fs.readFile(vscode.Uri.file(path.join(root, relPath)));
+                return Buffer.from(raw).toString("utf-8");
+            }
+        } catch { /* skip */ }
+        return undefined;
+    }
+
+    private async httpPost(url: string, payload: unknown, token: string | undefined, http: any): Promise<boolean> {
+        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<boolean>((resolve) => {
+            const req = http.request(url, { method: "POST", headers }, (res: any) => {
+                res.on("data", () => {});
+                res.on("end", () => resolve(res.statusCode === 200));
+            });
+            req.on("error", () => resolve(false));
+            req.write(body);
+            req.end();
+        });
+    }
+}

package/extension/src/services/IndexingService.ts

@@ -0,0 +1,101 @@
+/**
+ * IndexingService — orchestrates workspace indexing with injected dependencies.
+ */
+import * as vscode from "vscode";
+import * as path from "path";
+import { IndexerHttpClient } from "./IndexerHttpClient";
+import { convertFileToMarkdown } from "../converter";
+import { discoverDocuments } from "../indexer-discovery";
+
+export interface IndexOptions {
+    code: boolean;
+    documents: boolean;
+    sync: boolean;
+}
+
+export type ProgressReporter = vscode.Progress<{ message?: string }>;
+
+export class IndexingService {
+    constructor(private readonly httpClient: IndexerHttpClient) {}
+
+    async indexWorkspace(root: string, options: IndexOptions, token?: string): Promise<string[]> {
+        const results: string[] = [];
+
+        await vscode.window.withProgress(
+            { location: vscode.ProgressLocation.Notification, title: "Indexing workspace...", cancellable: false },
+            async (report) => {
+                if (options.code) {
+                    report.report({ message: "Scanning and uploading source code files..." });
+                    const res = await this.httpClient.uploadSourceFiles(report, token);
+                    results.push(res.summary);
+                }
+                if (options.documents) {
+                    report.report({ message: "Discovering documents..." });
+                    results.push(await this.indexDocuments(root, report, token));
+                }
+                if (options.sync) {
+                    report.report({ message: "Syncing code symbols to memory..." });
+                    results.push("✅ Code symbol sync triggered");
+                }
+            }
+        );
+
+        return results;
+    }
+
+    async indexDocuments(root: string, report: ProgressReporter, token?: string): Promise<string> {
+        const docs = discoverDocuments(root);
+        if (docs.length === 0) { return "ℹ️ No documents found in documents/ folder"; }
+
+        const mdDocs = docs.filter(d => d.format === "markdown");
+        const nonMdDocs = docs.filter(d => d.format !== "markdown");
+        report.report({ message: `Found ${docs.length} files (${nonMdDocs.length} need conversion)` });
+
+        const convertedDocs: Array<{ path: string; type: string; ticket: string; format: string; content?: string }> = [];
+        let convertedCount = 0;
+        let skippedCount = 0;
+        const errors: Array<{ file: string; error: string }> = [];
+        const channel = vscode.window.createOutputChannel("SDLC Indexing");
+
+        for (let i = 0; i < nonMdDocs.length; i++) {
+            const doc = nonMdDocs[i];
+            report.report({ message: `Converting ${i + 1}/${nonMdDocs.length} files...` });
+            const absPath = path.join(root, doc.path);
+            const result = await convertFileToMarkdown(absPath, doc.format, token);
+            if (result.success && result.markdown && result.markdown.trim().length > 0) {
+                convertedDocs.push({ ...doc, content: result.markdown });
+                convertedCount++;
+                channel.appendLine(`  ✅ Converted: ${doc.path} (${result.conversionTime}ms)`);
+            } else {
+                skippedCount++;
+                if (!result.success) { errors.push({ file: doc.path, error: result.error || "unknown" }); }
+                channel.appendLine(`  ⏭️ Skipped: ${doc.path}`);
+            }
+        }
+
+        const allDocsForIngest = [...mdDocs, ...convertedDocs];
+        report.report({ message: `Indexing ${allDocsForIngest.length} files...` });
+        const apiResult = await this.httpClient.ingestDocuments(allDocsForIngest, report, token);
+
+        return this.buildSummary(docs.length, mdDocs.length, convertedCount, skippedCount, apiResult.summary, errors);
+    }
+
+    private buildSummary(
+        total: number, direct: number, converted: number, skipped: number,
+        apiSummary: string, errors: Array<{ file: string; error: string }>
+    ): string {
+        const summary = [
+            `✅ Documents: ${total} discovered`,
+            `   📄 Direct: ${direct}`,
+            `   🔄 Converted: ${converted}`,
+            `   ⏭️ Skipped: ${skipped}`,
+            `   ${apiSummary}`,
+        ];
+        if (errors.length > 0) {
+            summary.push(`   ⚠️ Errors:`);
+            for (const e of errors.slice(0, 5)) { summary.push(`      - ${path.basename(e.file)}: ${e.error}`); }
+            if (errors.length > 5) { summary.push(`      ... and ${errors.length - 5} more`); }
+        }
+        return summary.join("\n");
+    }
+}

package/extension/src/services/LlmTestService.ts

@@ -0,0 +1,96 @@
+/**
+ * LlmTestService — handles LLM connection testing logic.
+ * Extracted from SettingsPanel for SRP.
+ */
+
+import * as vscode from "vscode";
+import { createProviderByType } from "../langgraph/providers";
+import { PROVIDER_BASE_URL_KEYS, PROVIDER_BASE_URL_DEFAULTS } from "../models";
+
+const TEST_TIMEOUT_MS = 10000;
+const AUTO_TEST_TIMEOUT_MS = 8000;
+
+export class LlmTestService {
+  constructor(private readonly secrets: vscode.SecretStorage) {}
+
+  /**
+   * Test LLM connection with given provider/baseUrl overrides.
+   * Returns result and fires appropriate VS Code commands.
+   */
+  async testLlm(
+    providerOverride?: string,
+    baseUrlOverride?: string
+  ): Promise<{ success: boolean; message?: string; error?: string }> {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    const providerType = providerOverride || config.get<string>("llmProvider", "anthropic");
+    const ollamaUrl = config.get<string>("ollamaUrl", "http://localhost:11434");
+
+    const anthropicBaseUrl = providerType === "anthropic"
+      ? (baseUrlOverride || config.get<string>("anthropicBaseUrl", ""))
+      : "";
+    const openaiBaseUrl = providerType !== "anthropic"
+      ? (baseUrlOverride || config.get<string>("openaiBaseUrl", ""))
+      : "";
+
+    try {
+      const provider = createProviderByType(
+        providerType as any, this.secrets, undefined,
+        ollamaUrl, anthropicBaseUrl, openaiBaseUrl
+      );
+      const timeoutPromise = new Promise<boolean>((_, reject) =>
+        setTimeout(() => reject(new Error("Connection test timed out after 10s")), TEST_TIMEOUT_MS)
+      );
+      const available = await Promise.race([provider.isAvailable(), timeoutPromise]);
+      provider.dispose();
+
+      if (available) {
+        vscode.commands.executeCommand("kiroSdlc.notifyLlmConnected");
+        return { success: true, message: `Connected to ${providerType} successfully.` };
+      }
+      vscode.commands.executeCommand("kiroSdlc.notifyLlmDisconnected");
+      return { success: false, error: "LLM provider is not reachable. Check your base URL." };
+    } catch (err: any) {
+      vscode.commands.executeCommand("kiroSdlc.notifyLlmDisconnected");
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * Auto-test a provider and notify chat panel badge.
+   */
+  async autoTestAndNotify(provider: string): Promise<{ success: boolean; message?: string; error?: string }> {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    const ollamaUrl = config.get<string>("ollamaUrl", "http://localhost:11434");
+
+    const baseUrlKey = PROVIDER_BASE_URL_KEYS[provider];
+    const defaultUrl = PROVIDER_BASE_URL_DEFAULTS[provider] || "";
+    const baseUrl = baseUrlKey
+      ? (config.get<string>(baseUrlKey, "") || defaultUrl)
+      : "";
+
+    const anthropicBaseUrl = provider === "anthropic" ? baseUrl : "";
+    const openaiBaseUrl = provider !== "anthropic" ? baseUrl : "";
+
+    try {
+      const testProvider = createProviderByType(
+        provider as any, this.secrets, undefined,
+        ollamaUrl, anthropicBaseUrl, openaiBaseUrl
+      );
+      const timeoutPromise = new Promise<boolean>((_, reject) =>
+        setTimeout(() => reject(new Error("timeout")), AUTO_TEST_TIMEOUT_MS)
+      );
+      const available = await Promise.race([testProvider.isAvailable(), timeoutPromise]);
+      testProvider.dispose();
+
+      if (available) {
+        vscode.commands.executeCommand("kiroSdlc.notifyLlmConnected");
+        return { success: true, message: `Connected to ${provider} successfully.` };
+      }
+      vscode.commands.executeCommand("kiroSdlc.notifyLlmDisconnected");
+      return { success: false, error: "LLM provider is not reachable." };
+    } catch {
+      vscode.commands.executeCommand("kiroSdlc.notifyLlmDisconnected");
+      return { success: false, error: "Connection test failed." };
+    }
+  }
+}

package/extension/src/services/ProviderConfigService.ts

@@ -0,0 +1,85 @@
+/**
+ * ProviderConfigService — manages reading/writing LLM provider configuration.
+ * Extracted from SettingsPanel for SRP.
+ */
+
+import * as vscode from "vscode";
+import { getStaticModels, fetchGatewayModels, getDefaultModel } from "../chat-panel/chat-models";
+import { SECRET_KEYS, PROVIDER_BASE_URL_KEYS, PROVIDER_BASE_URL_DEFAULTS } from "../models";
+
+export class ProviderConfigService {
+  constructor(private readonly secrets: vscode.SecretStorage) {}
+
+  /**
+   * Build current settings state to send to webview.
+   */
+  async getCurrentState(): Promise<{
+    provider: string; model: string; ollamaUrl: string; baseUrl: string;
+    hasAnthropicKey: boolean; hasOpenaiKey: boolean;
+    backendUrl: string; mcpServerPort: number; enableMcpServer: boolean;
+  }> {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    const provider = config.get<string>("llmProvider", "anthropic");
+    const model = config.get<string>("llmModel", "");
+    const ollamaUrl = config.get<string>("ollamaUrl", "http://localhost:11434");
+
+    const baseUrl = this.getBaseUrlForProvider(provider);
+    const backendUrl = config.get<string>("backend.url", "http://127.0.0.1:48721");
+    const mcpServerPort = config.get<number>("mcpServerPort", 9181);
+    const enableMcpServer = config.get<boolean>("enableMcpServer", true);
+
+    const anthropicKey = await this.secrets.get(SECRET_KEYS.anthropic);
+    const openaiKey = await this.secrets.get(SECRET_KEYS.openai);
+
+    return {
+      provider, model, ollamaUrl, baseUrl: baseUrl || "",
+      hasAnthropicKey: !!anthropicKey, hasOpenaiKey: !!openaiKey,
+      backendUrl, mcpServerPort, enableMcpServer,
+    };
+  }
+
+  /**
+   * Build the provider-aware model list.
+   */
+  async getModels(provider: string, currentModel: string): Promise<{
+    models: any[]; selected: string; defaultModel: string;
+  }> {
+    let models = getStaticModels(provider);
+    const gatewayBaseUrl = this.getGatewayBaseUrl(provider);
+
+    if (gatewayBaseUrl) {
+      const gatewayModels = await fetchGatewayModels(gatewayBaseUrl);
+      if (gatewayModels && gatewayModels.length > 0) {
+        models = gatewayModels;
+      }
+    }
+
+    let selected = currentModel;
+    if (!selected || !models.some((m: any) => m.id === selected)) {
+      selected = models.length > 0 ? models[0].id : getDefaultModel(provider);
+    }
+
+    return { models, selected, defaultModel: getDefaultModel(provider) };
+  }
+
+  /** Update a kiroSdlc configuration key globally. */
+  async updateConfig(key: string, value: any): Promise<void> {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    await config.update(key, value || undefined, vscode.ConfigurationTarget.Global);
+  }
+
+  private getBaseUrlForProvider(provider: string): string {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    const key = PROVIDER_BASE_URL_KEYS[provider];
+    if (!key) { return ""; }
+    return config.get<string>(key, "");
+  }
+
+  private getGatewayBaseUrl(provider: string): string {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    const key = PROVIDER_BASE_URL_KEYS[provider];
+    if (!key) { return ""; }
+    const configuredUrl = config.get<string>(key, "");
+    return configuredUrl || PROVIDER_BASE_URL_DEFAULTS[provider] || "";
+  }
+}

package/extension/src/services/WorkspaceSyncService.ts

@@ -0,0 +1,48 @@
+/**
+ * WorkspaceSyncService — Syncs file tree metadata to remote backend.
+ * Sends relative paths only (no file content, no absolute paths).
+ */
+
+import * as vscode from "vscode";
+import { HttpClient } from "../proxy/HttpClient";
+
+export class WorkspaceSyncService implements vscode.Disposable {
+  private watcher: vscode.Disposable | undefined;
+
+  constructor(private readonly httpClient: HttpClient) {}
+
+  /**
+   * Start watching for workspace folder changes.
+   */
+  startWatching(): void {
+    this.watcher = vscode.workspace.onDidChangeWorkspaceFolders(() => this.sync());
+  }
+
+  /**
+   * Sync the file tree to the backend.
+   */
+  async sync(): Promise<void> {
+    const files = await vscode.workspace.findFiles(
+      "**/*",
+      "{node_modules,dist,.git,build,out,.code-intel}/**"
+    );
+    const tree = {
+      workspace_name: vscode.workspace.name || "unknown",
+      files: await Promise.all(
+        files.slice(0, 10000).map(async (f) => {
+          const stat = await vscode.workspace.fs.stat(f);
+          return {
+            path: vscode.workspace.asRelativePath(f),
+            type: "file" as const,
+            size: stat.size,
+          };
+        })
+      ),
+    };
+    await this.httpClient.post("/api/workspace/sync", tree, 30000);
+  }
+
+  dispose(): void {
+    this.watcher?.dispose();
+  }
+}