feat: add ContextExpressionClient and centralize route handling

- Introduced ContextExpressionClient to encapsulate API calls for \/resolveContextExpression\, applying settings, timeout and logging
- Updated contextHelp.ts to consume the new client instead of creating SourceControlApi manually
- Added routes.ts with BASE_PATH and resolveContextExpression route
- Updated extension.ts to import CCS commands/providers from barrel
- Adapted SourceControlApi client to use centralized routes (only resolveContextExpression for now)

Author: LeoAnders

src/ccs/commands/contextHelp.ts

@@ -1,15 +1,10 @@
 import * as path from "path";
 import * as vscode from "vscode";
 
-import { AtelierAPI } from "../../api";
+import { ContextExpressionClient } from "../sourcecontrol/contextExpressionClient";
 import { handleError } from "../../utils";
-import { SourceControlApi } from "../sourcecontrol/client";
 
-interface ResolveContextExpressionResponse {
-  status?: string;
-  textExpression?: string;
-  message?: string;
-}
+const sharedClient = new ContextExpressionClient();
 
 export async function resolveContextExpression(): Promise<void> {
   const editor = vscode.window.activeTextEditor;
@@ -28,23 +23,11 @@ export async function resolveContextExpression(): Promise<void> {
   }
 
   const routine = path.basename(document.fileName);
-  const api = new AtelierAPI(document.uri);
-
-  let sourceControlApi: SourceControlApi;
-  try {
-    sourceControlApi = SourceControlApi.fromAtelierApi(api);
-  } catch (error) {
-    void vscode.window.showErrorMessage(error instanceof Error ? error.message : String(error));
-    return;
-  }
 
   try {
-    const response = await sourceControlApi.post<ResolveContextExpressionResponse>("/resolveContextExpression", {
-      routine,
-      contextExpression,
-    });
+    const response = await sharedClient.resolve(document, { routine, contextExpression });
+    const data = response ?? {};
 
-    const data = response.data ?? {};
     if (typeof data.status === "string" && data.status.toLowerCase() === "success" && data.textExpression) {
       const eol = document.eol === vscode.EndOfLine.CRLF ? "\r\n" : "\n";
       const textExpression = data.textExpression.replace(/\r?\n/g, eol);

src/ccs/index.ts

@@ -1,2 +1,5 @@
+export { getCcsSettings, isFlagEnabled, type CcsSettings } from "./config/settings";
+export { logDebug, logError, logInfo, logWarn } from "./core/logging";
 export { SourceControlApi } from "./sourcecontrol/client";
 export { resolveContextExpression } from "./commands/contextHelp";
+export { ContextExpressionClient } from "./sourcecontrol/contextExpressionClient";

src/ccs/sourcecontrol/client.ts

@@ -1,7 +1,10 @@
-import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
-import * as https from "https";
-import * as vscode from "vscode";
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios";
+
 import { AtelierAPI } from "../../api";
+import { getCcsSettings } from "../config/settings";
+import { createHttpClient } from "../core/http";
+import { logDebug } from "../core/logging";
+import { BASE_PATH } from "./routes";
 
 export class SourceControlApi {
   private readonly client: AxiosInstance;
@@ -18,35 +21,37 @@ export class SourceControlApi {
     }
 
     const normalizedPrefix = pathPrefix ? (pathPrefix.startsWith("/") ? pathPrefix : `/${pathPrefix}`) : "";
-    const baseUrl = `${useHttps ? "https" : "http"}://${host}:${port}${encodeURI(normalizedPrefix)}`;
-
-    const httpsAgent = new https.Agent({
-      rejectUnauthorized: vscode.workspace.getConfiguration("http").get("proxyStrictSSL"),
-    });
-
-    const client = axios.create({
-      baseURL: `${baseUrl}/api/sourcecontrol/vscode`,
-      headers: {
-        "Content-Type": "application/json",
-      },
-      httpsAgent,
-      auth:
-        typeof username === "string" && typeof password === "string"
-          ? {
-              username,
-              password,
-            }
-          : undefined,
+    const trimmedPrefix = normalizedPrefix.endsWith("/") ? normalizedPrefix.slice(0, -1) : normalizedPrefix;
+    const encodedPrefix = encodeURI(trimmedPrefix);
+    const protocol = useHttps ? "https" : "http";
+    const defaultBaseUrl = `${protocol}://${host}:${port}${encodedPrefix}${BASE_PATH}`;
+
+    const { endpoint, requestTimeout } = getCcsSettings();
+    const baseURL = endpoint ?? defaultBaseUrl;
+    const auth =
+      typeof username === "string" && typeof password === "string"
+        ? {
+            username,
+            password,
+          }
+        : undefined;
+
+    logDebug("Creating SourceControl API client", { baseURL, hasAuth: Boolean(auth) });
+
+    const client = createHttpClient({
+      baseURL,
+      auth,
+      defaultTimeout: requestTimeout,
     });
 
     return new SourceControlApi(client);
   }
 
   public post<T = unknown, R = AxiosResponse<T>>(
-    endpoint: string,
+    route: string,
     data?: unknown,
     config?: AxiosRequestConfig<unknown>
   ): Promise<R> {
-    return this.client.post<T, R>(endpoint, data, config);
+    return this.client.post<T, R>(route, data, config);
   }
 }

src/ccs/sourcecontrol/contextExpressionClient.ts

@@ -0,0 +1,54 @@
+import * as vscode from "vscode";
+
+import { AtelierAPI } from "../../api";
+import { getCcsSettings } from "../config/settings";
+import { logDebug } from "../core/logging";
+import { ResolveContextExpressionResponse } from "../core/types";
+import { SourceControlApi } from "./client";
+import { ROUTES } from "./routes";
+
+interface ResolveContextExpressionPayload {
+  routine: string;
+  contextExpression: string;
+}
+
+export class ContextExpressionClient {
+  private readonly apiFactory: (api: AtelierAPI) => SourceControlApi;
+
+  public constructor(apiFactory: (api: AtelierAPI) => SourceControlApi = SourceControlApi.fromAtelierApi) {
+    this.apiFactory = apiFactory;
+  }
+
+  public async resolve(
+    document: vscode.TextDocument,
+    payload: ResolveContextExpressionPayload
+  ): Promise<ResolveContextExpressionResponse> {
+    const api = new AtelierAPI(document.uri);
+
+    let sourceControlApi: SourceControlApi;
+    try {
+      sourceControlApi = this.apiFactory(api);
+    } catch (error) {
+      logDebug("Failed to create SourceControl API client for context expression", error);
+      throw error;
+    }
+
+    const { requestTimeout } = getCcsSettings();
+
+    try {
+      const response = await sourceControlApi.post<ResolveContextExpressionResponse>(
+        ROUTES.resolveContextExpression(),
+        payload,
+        {
+          timeout: requestTimeout,
+          validateStatus: (status) => status >= 200 && status < 300,
+        }
+      );
+
+      return response.data ?? {};
+    } catch (error) {
+      logDebug("Context expression resolution failed", error);
+      throw error;
+    }
+  }
+}

src/ccs/sourcecontrol/routes.ts

@@ -0,0 +1,7 @@
+export const BASE_PATH = "/api/sourcecontrol/vscode" as const;
+
+export const ROUTES = {
+  resolveContextExpression: () => `/resolveContextExpression`,
+} as const;
+
+export type RouteKey = keyof typeof ROUTES;